Full Code of philsquared/Clara for AI

master 2bfd8b202832 cached
32 files
601.8 KB
140.1k tokens
1460 symbols
1 requests
Download .txt
Showing preview only (622K chars total). Download the full file or copy to clipboard to get everything.
Repository: philsquared/Clara
Branch: master
Commit: 2bfd8b202832
Files: 32
Total size: 601.8 KB

Directory structure:
gitextract_vb6dyj94/

├── .gitattributes
├── .gitignore
├── .travis.yml
├── CMake/
│   ├── FindGcov.cmake
│   ├── FindLcov.cmake
│   ├── Findcodecov.cmake
│   └── llvm-cov-wrapper
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── LICENSE.txt
├── README.md
├── Roadmap.md
├── appveyor.yml
├── codecov.yml
├── docs/
│   └── release-notes.md
├── include/
│   ├── clara.hpp
│   └── clara_textflow.hpp
├── misc/
│   ├── CMakeLists.txt
│   ├── appveyorBuildConfigurationScript.bat
│   ├── appveyorMergeCoverageScript.py
│   ├── appveyorTestRunScript.bat
│   ├── coverage-helper.cpp
│   └── installOpenCppCoverage.ps1
├── scripts/
│   ├── embed.py
│   ├── embedTextFlow.py
│   ├── release.py
│   └── stitch.py
├── single_include/
│   └── clara.hpp
├── src/
│   ├── ClaraTests.cpp
│   └── main.cpp
└── third_party/
    ├── TextFlow.hpp
    └── catch.hpp

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitattributes
================================================
# This sets the default behaviour, overriding core.autocrlf
* text=auto

# All source files should have unix line-endings in the repository,
# but convert to native line-endings on checkout
*.cpp text
*.h text
*.hpp text

# Windows specific files should retain windows line-endings
*.sln text eol=crlf

# Keep executable scripts with LFs so they can be run after being
# checked out on Windows
*.py text eol=lf


# Keep the single include header with LFs to make sure it is uploaded,
# hashed etc with LF
single_include/*.hpp eol=lf
# Also keep the LICENCE file with LFs for the same reason
LICENCE.txt eol=lf


================================================
FILE: .gitignore
================================================
.idea/*.iml
.idea/misc.xml
.idea/modules.xml
.idea/vcs.xml
.idea/workspace.xml
.idea/.name
.idea/dictionaries/*
cmake-build-*
.vs
*.pyc
.idea/markdown-navigator.xml
.idea/codeStyles/Project.xml
.idea/markdown-navigator/profiles_settings.xml


================================================
FILE: .travis.yml
================================================
language: cpp
sudo: false

common_sources: &all_sources
  - ubuntu-toolchain-r-test
  - llvm-toolchain-trusty
  - llvm-toolchain-trusty-3.9
  - llvm-toolchain-trusty-4.0
  - llvm-toolchain-trusty-5.0

matrix:
  include:

    # 1/ Linux Clang Builds
    - os: linux
      compiler: clang
      addons:
        apt:
          sources: *all_sources
          packages: ['valgrind', 'lcov', 'clang-3.5']
      env: COMPILER='clang++-3.5' VALGRIND=1

    - os: linux
      compiler: clang
      addons:
        apt:
          sources: *all_sources
          packages: ['valgrind', 'lcov', 'clang-3.6']
      env: COMPILER='clang++-3.6' VALGRIND=1

# Travis's containers do not seem to have Clang 3.7 in apt, no matter what sources I add.
#    - os: linux
#      compiler: clang
#      addons:
#        apt:
#          sources: *all_sources
#          packages: ['valgrind', 'clang-3.7']
#      env: COMPILER='clang++-3.7' VALGRIND=1

    - os: linux
      compiler: clang
      addons:
        apt:
          sources: *all_sources
          packages: ['valgrind', 'lcov', 'clang-3.8']
      env: COMPILER='clang++-3.8' VALGRIND=1

    - os: linux
      compiler: clang
      addons:
          apt:
              sources: *all_sources
              packages: ['clang-3.9', 'valgrind', 'lcov']
      env: COMPILER='clang++-3.9' VALGRIND=1

    - os: linux
      compiler: clang
      addons:
          apt:
              sources: *all_sources
              packages: ['clang-4.0', 'valgrind', 'lcov']
      env: COMPILER='clang++-4.0' VALGRIND=1

    - os: linux
      compiler: clang
      addons:
          apt:
              sources: *all_sources
              packages: ['clang-5.0', 'valgrind', 'lcov']
      env: COMPILER='clang++-5.0' VALGRIND=1

    # 2/ Linux GCC Builds
    - os: linux
      compiler: gcc
      addons:
        apt:
         sources: ['ubuntu-toolchain-r-test']
         packages: ['valgrind', 'lcov', 'g++-4.8']
      env: COMPILER='g++-4.8' VALGRIND=1 COVERAGE=1

    - os: linux
      compiler: gcc
      addons:
        apt:
          sources: *all_sources
          packages: ['valgrind', 'lcov', 'g++-4.9']
      env: COMPILER='g++-4.9' VALGRIND=1

    - os: linux
      compiler: gcc
      addons:
        apt:
          sources: *all_sources
          packages: ['valgrind', 'lcov', 'g++-5']
      env: COMPILER='g++-5' VALGRIND=1

    - os: linux
      compiler: gcc
      addons: &gcc6
        apt:
          sources: *all_sources
          packages: ['valgrind', 'lcov', 'g++-6']
      env: COMPILER='g++-6' VALGRIND=1

    - os: linux
      compiler: gcc
      addons: &gcc7
        apt:
          sources: *all_sources
          packages: ['valgrind', 'lcov', 'g++-7']
      env: COMPILER='g++-7' VALGRIND=1
      
    - os: linux
      compiler: gcc
      addons: *gcc7
      env: COMPILER='g++-7' CPP17=1 COVERAGE=1

    # 5/ OSX Clang Builds
    - os: osx
      osx_image: xcode8.3
      compiler: clang
      env: COMPILER='clang++'

    - os: osx
      osx_image: xcode9
      compiler: clang
      env: COMPILER='clang++'

    - os: osx
      osx_image: xcode9.1
      compiler: clang
      env: COMPILER='clang++'

    - os: osx
      osx_image: xcode9.1
      compiler: clang
      env: COMPILER='clang++' CPP14=1


install:
  - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
  - mkdir -p ${DEPS_DIR} && cd ${DEPS_DIR}
  - |
    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
      CMAKE_URL="http://cmake.org/files/v3.8/cmake-3.8.2-Linux-x86_64.tar.gz"
      mkdir cmake && travis_retry wget --no-check-certificate --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
      export PATH=${DEPS_DIR}/cmake/bin:${PATH}
    elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
        which cmake || brew install cmake;
    fi

before_script:
  - export CXX=${COMPILER}
  - cd ${TRAVIS_BUILD_DIR}
    # Use Debug builds for collecting coverage
  - cmake -H. -BBuild-Debug -DCMAKE_BUILD_TYPE=Debug -DENABLE_COVERAGE=${COVERAGE} -DUSE_CPP14=${CPP14} -DUSE_CPP17=${CPP17}
    # Don't bother with release build for coverage build
  - cmake -H. -BBuild-Release -DCMAKE_BUILD_TYPE=Release


script:
  - cd Build-Debug
  - make -j 2
  - CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
  - |
    # Coverage collection does not work for OS X atm
    if [[ "${COVERAGE}" == "1" ]]; then
      make gcov
      make lcov
      bash <(curl -s https://codecov.io/bash) -X gcov || echo "Codecov did not collect coverage reports"
    fi
    # Go to release build
  - cd ../Build-Release
  - make -j 2
  - CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2


================================================
FILE: CMake/FindGcov.cmake
================================================
# This file is part of CMake-codecov.
#
# Copyright (c)
#   2015-2017 RWTH Aachen University, Federal Republic of Germany
#
# See the LICENSE file in the package base directory for details
#
# Written by Alexander Haase, alexander.haase@rwth-aachen.de
#


# include required Modules
include(FindPackageHandleStandardArgs)


# Search for gcov binary.
set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
set(CMAKE_REQUIRED_QUIET ${codecov_FIND_QUIETLY})

get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
foreach (LANG ${ENABLED_LANGUAGES})
	# Gcov evaluation is dependend on the used compiler. Check gcov support for
	# each compiler that is used. If gcov binary was already found for this
	# compiler, do not try to find it again.
	if (NOT GCOV_${CMAKE_${LANG}_COMPILER_ID}_BIN)
		get_filename_component(COMPILER_PATH "${CMAKE_${LANG}_COMPILER}" PATH)

		if ("${CMAKE_${LANG}_COMPILER_ID}" STREQUAL "GNU")
			# Some distributions like OSX (homebrew) ship gcov with the compiler
			# version appended as gcov-x. To find this binary we'll build the
			# suggested binary name with the compiler version.
			string(REGEX MATCH "^[0-9]+" GCC_VERSION
				"${CMAKE_${LANG}_COMPILER_VERSION}")

			find_program(GCOV_BIN NAMES gcov-${GCC_VERSION} gcov
				HINTS ${COMPILER_PATH})

		elseif ("${CMAKE_${LANG}_COMPILER_ID}" STREQUAL "Clang")
			# Some distributions like Debian ship llvm-cov with the compiler
			# version appended as llvm-cov-x.y. To find this binary we'll build
			# the suggested binary name with the compiler version.
			string(REGEX MATCH "^[0-9]+.[0-9]+" LLVM_VERSION
				"${CMAKE_${LANG}_COMPILER_VERSION}")

			# llvm-cov prior version 3.5 seems to be not working with coverage
			# evaluation tools, but these versions are compatible with the gcc
			# gcov tool.
			if(LLVM_VERSION VERSION_GREATER 3.4)
				find_program(LLVM_COV_BIN NAMES "llvm-cov-${LLVM_VERSION}"
					"llvm-cov" HINTS ${COMPILER_PATH})
				mark_as_advanced(LLVM_COV_BIN)

				if (LLVM_COV_BIN)
					find_program(LLVM_COV_WRAPPER "llvm-cov-wrapper" PATHS
						${CMAKE_MODULE_PATH})
					if (LLVM_COV_WRAPPER)
						set(GCOV_BIN "${LLVM_COV_WRAPPER}" CACHE FILEPATH "")

						# set additional parameters
						set(GCOV_${CMAKE_${LANG}_COMPILER_ID}_ENV
							"LLVM_COV_BIN=${LLVM_COV_BIN}" CACHE STRING
							"Environment variables for llvm-cov-wrapper.")
						mark_as_advanced(GCOV_${CMAKE_${LANG}_COMPILER_ID}_ENV)
					endif ()
				endif ()
			endif ()

			if (NOT GCOV_BIN)
				# Fall back to gcov binary if llvm-cov was not found or is
				# incompatible. This is the default on OSX, but may crash on
				# recent Linux versions.
				find_program(GCOV_BIN gcov HINTS ${COMPILER_PATH})
			endif ()
		endif ()


		if (GCOV_BIN)
			set(GCOV_${CMAKE_${LANG}_COMPILER_ID}_BIN "${GCOV_BIN}" CACHE STRING
				"${LANG} gcov binary.")

			if (NOT CMAKE_REQUIRED_QUIET)
				message("-- Found gcov evaluation for "
				"${CMAKE_${LANG}_COMPILER_ID}: ${GCOV_BIN}")
			endif()

			unset(GCOV_BIN CACHE)
		endif ()
	endif ()
endforeach ()




# Add a new global target for all gcov targets. This target could be used to
# generate the gcov files for the whole project instead of calling <TARGET>-gcov
# for each target.
if (NOT TARGET gcov)
	add_custom_target(gcov)
endif (NOT TARGET gcov)



# This function will add gcov evaluation for target <TNAME>. Only sources of
# this target will be evaluated and no dependencies will be added. It will call
# Gcov on any source file of <TNAME> once and store the gcov file in the same
# directory.
function (add_gcov_target TNAME)
	set(TDIR ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${TNAME}.dir)

	# We don't have to check, if the target has support for coverage, thus this
	# will be checked by add_coverage_target in Findcoverage.cmake. Instead we
	# have to determine which gcov binary to use.
	get_target_property(TSOURCES ${TNAME} SOURCES)
	set(SOURCES "")
	set(TCOMPILER "")
	foreach (FILE ${TSOURCES})
		codecov_path_of_source(${FILE} FILE)
		if (NOT "${FILE}" STREQUAL "")
			codecov_lang_of_source(${FILE} LANG)
			if (NOT "${LANG}" STREQUAL "")
				list(APPEND SOURCES "${FILE}")
				set(TCOMPILER ${CMAKE_${LANG}_COMPILER_ID})
			endif ()
		endif ()
	endforeach ()

	# If no gcov binary was found, coverage data can't be evaluated.
	if (NOT GCOV_${TCOMPILER}_BIN)
		message(WARNING "No coverage evaluation binary found for ${TCOMPILER}.")
		return()
	endif ()

	set(GCOV_BIN "${GCOV_${TCOMPILER}_BIN}")
	set(GCOV_ENV "${GCOV_${TCOMPILER}_ENV}")


	set(BUFFER "")
	foreach(FILE ${SOURCES})
		get_filename_component(FILE_PATH "${TDIR}/${FILE}" PATH)

		# call gcov
		add_custom_command(OUTPUT ${TDIR}/${FILE}.gcov
			COMMAND ${GCOV_ENV} ${GCOV_BIN} ${TDIR}/${FILE}.gcno > /dev/null
			DEPENDS ${TNAME} ${TDIR}/${FILE}.gcno
			WORKING_DIRECTORY ${FILE_PATH}
		)

		list(APPEND BUFFER ${TDIR}/${FILE}.gcov)
	endforeach()


	# add target for gcov evaluation of <TNAME>
	add_custom_target(${TNAME}-gcov DEPENDS ${BUFFER})

	# add evaluation target to the global gcov target.
	add_dependencies(gcov ${TNAME}-gcov)
endfunction (add_gcov_target)


================================================
FILE: CMake/FindLcov.cmake
================================================
# This file is part of CMake-codecov.
#
# Copyright (c)
#   2015-2017 RWTH Aachen University, Federal Republic of Germany
#
# See the LICENSE file in the package base directory for details
#
# Written by Alexander Haase, alexander.haase@rwth-aachen.de
#


# configuration
set(LCOV_DATA_PATH "${CMAKE_BINARY_DIR}/lcov/data")
set(LCOV_DATA_PATH_INIT "${LCOV_DATA_PATH}/init")
set(LCOV_DATA_PATH_CAPTURE "${LCOV_DATA_PATH}/capture")
set(LCOV_HTML_PATH "${CMAKE_BINARY_DIR}/lcov/html")




# Search for Gcov which is used by Lcov.
find_package(Gcov)




# This function will add lcov evaluation for target <TNAME>. Only sources of
# this target will be evaluated and no dependencies will be added. It will call
# geninfo on any source file of <TNAME> once and store the info file in the same
# directory.
#
# Note: This function is only a wrapper to define this function always, even if
#   coverage is not supported by the compiler or disabled. This function must
#   be defined here, because the module will be exited, if there is no coverage
#   support by the compiler or it is disabled by the user.
function (add_lcov_target TNAME)
	if (LCOV_FOUND)
		# capture initial coverage data
		lcov_capture_initial_tgt(${TNAME})

		# capture coverage data after execution
		lcov_capture_tgt(${TNAME})
	endif ()
endfunction (add_lcov_target)




# include required Modules
include(FindPackageHandleStandardArgs)

# Search for required lcov binaries.
find_program(LCOV_BIN lcov)
find_program(GENINFO_BIN geninfo)
find_program(GENHTML_BIN genhtml)
find_package_handle_standard_args(lcov
	REQUIRED_VARS LCOV_BIN GENINFO_BIN GENHTML_BIN
)

# enable genhtml C++ demangeling, if c++filt is found.
set(GENHTML_CPPFILT_FLAG "")
find_program(CPPFILT_BIN c++filt)
if (NOT CPPFILT_BIN STREQUAL "")
	set(GENHTML_CPPFILT_FLAG "--demangle-cpp")
endif (NOT CPPFILT_BIN STREQUAL "")

# enable no-external flag for lcov, if available.
if (GENINFO_BIN AND NOT DEFINED GENINFO_EXTERN_FLAG)
	set(FLAG "")
	execute_process(COMMAND ${GENINFO_BIN} --help OUTPUT_VARIABLE GENINFO_HELP)
	string(REGEX MATCH "external" GENINFO_RES "${GENINFO_HELP}")
	if (GENINFO_RES)
		set(FLAG "--no-external")
	endif ()

	set(GENINFO_EXTERN_FLAG "${FLAG}"
		CACHE STRING "Geninfo flag to exclude system sources.")
endif ()

# If Lcov was not found, exit module now.
if (NOT LCOV_FOUND)
	return()
endif (NOT LCOV_FOUND)




# Create directories to be used.
file(MAKE_DIRECTORY ${LCOV_DATA_PATH_INIT})
file(MAKE_DIRECTORY ${LCOV_DATA_PATH_CAPTURE})

set(LCOV_REMOVE_PATTERNS "")

# This function will merge lcov files to a single target file. Additional lcov
# flags may be set with setting LCOV_EXTRA_FLAGS before calling this function.
function (lcov_merge_files OUTFILE ...)
	# Remove ${OUTFILE} from ${ARGV} and generate lcov parameters with files.
	list(REMOVE_AT ARGV 0)

	# Generate merged file.
	string(REPLACE "${CMAKE_BINARY_DIR}/" "" FILE_REL "${OUTFILE}")
	add_custom_command(OUTPUT "${OUTFILE}.raw"
		COMMAND cat ${ARGV} > ${OUTFILE}.raw
		DEPENDS ${ARGV}
		COMMENT "Generating ${FILE_REL}"
	)

	add_custom_command(OUTPUT "${OUTFILE}"
		COMMAND ${LCOV_BIN} --quiet -a ${OUTFILE}.raw --output-file ${OUTFILE}
			--base-directory ${PROJECT_SOURCE_DIR} ${LCOV_EXTRA_FLAGS}
		COMMAND ${LCOV_BIN} --quiet -r ${OUTFILE} ${LCOV_REMOVE_PATTERNS}
			--output-file ${OUTFILE} ${LCOV_EXTRA_FLAGS}
		DEPENDS ${OUTFILE}.raw
		COMMENT "Post-processing ${FILE_REL}"
	)
endfunction ()




# Add a new global target to generate initial coverage reports for all targets.
# This target will be used to generate the global initial info file, which is
# used to gather even empty report data.
if (NOT TARGET lcov-capture-init)
	add_custom_target(lcov-capture-init)
	set(LCOV_CAPTURE_INIT_FILES "" CACHE INTERNAL "")
endif (NOT TARGET lcov-capture-init)


# This function will add initial capture of coverage data for target <TNAME>,
# which is needed to get also data for objects, which were not loaded at
# execution time. It will call geninfo for every source file of <TNAME> once and
# store the info file in the same directory.
function (lcov_capture_initial_tgt TNAME)
	# We don't have to check, if the target has support for coverage, thus this
	# will be checked by add_coverage_target in Findcoverage.cmake. Instead we
	# have to determine which gcov binary to use.
	get_target_property(TSOURCES ${TNAME} SOURCES)
	set(SOURCES "")
	set(TCOMPILER "")
	foreach (FILE ${TSOURCES})
		codecov_path_of_source(${FILE} FILE)
		if (NOT "${FILE}" STREQUAL "")
			codecov_lang_of_source(${FILE} LANG)
			if (NOT "${LANG}" STREQUAL "")
				list(APPEND SOURCES "${FILE}")
				set(TCOMPILER ${CMAKE_${LANG}_COMPILER_ID})
			endif ()
		endif ()
	endforeach ()

	# If no gcov binary was found, coverage data can't be evaluated.
	if (NOT GCOV_${TCOMPILER}_BIN)
		message(WARNING "No coverage evaluation binary found for ${TCOMPILER}.")
		return()
	endif ()

	set(GCOV_BIN "${GCOV_${TCOMPILER}_BIN}")
	set(GCOV_ENV "${GCOV_${TCOMPILER}_ENV}")


	set(TDIR ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${TNAME}.dir)
	set(GENINFO_FILES "")
	foreach(FILE ${SOURCES})
		# generate empty coverage files
		set(OUTFILE "${TDIR}/${FILE}.info.init")
		list(APPEND GENINFO_FILES ${OUTFILE})

		add_custom_command(OUTPUT ${OUTFILE} COMMAND ${GCOV_ENV} ${GENINFO_BIN}
				--quiet --base-directory ${PROJECT_SOURCE_DIR} --initial
				--gcov-tool ${GCOV_BIN} --output-filename ${OUTFILE}
				${GENINFO_EXTERN_FLAG} ${TDIR}/${FILE}.gcno
			DEPENDS ${TNAME}
			COMMENT "Capturing initial coverage data for ${FILE}"
		)
	endforeach()

	# Concatenate all files generated by geninfo to a single file per target.
	set(OUTFILE "${LCOV_DATA_PATH_INIT}/${TNAME}.info")
	set(LCOV_EXTRA_FLAGS "--initial")
	lcov_merge_files("${OUTFILE}" ${GENINFO_FILES})
	add_custom_target(${TNAME}-capture-init ALL DEPENDS ${OUTFILE})

	# add geninfo file generation to global lcov-geninfo target
	add_dependencies(lcov-capture-init ${TNAME}-capture-init)
	set(LCOV_CAPTURE_INIT_FILES "${LCOV_CAPTURE_INIT_FILES}"
		"${OUTFILE}" CACHE INTERNAL ""
	)
endfunction (lcov_capture_initial_tgt)


# This function will generate the global info file for all targets. It has to be
# called after all other CMake functions in the root CMakeLists.txt file, to get
# a full list of all targets that generate coverage data.
function (lcov_capture_initial)
	# Skip this function (and do not create the following targets), if there are
	# no input files.
	if ("${LCOV_CAPTURE_INIT_FILES}" STREQUAL "")
		return()
	endif ()

	# Add a new target to merge the files of all targets.
	set(OUTFILE "${LCOV_DATA_PATH_INIT}/all_targets.info")
	lcov_merge_files("${OUTFILE}" ${LCOV_CAPTURE_INIT_FILES})
	add_custom_target(lcov-geninfo-init ALL	DEPENDS ${OUTFILE}
		lcov-capture-init
	)
endfunction (lcov_capture_initial)




# Add a new global target to generate coverage reports for all targets. This
# target will be used to generate the global info file.
if (NOT TARGET lcov-capture)
	add_custom_target(lcov-capture)
	set(LCOV_CAPTURE_FILES "" CACHE INTERNAL "")
endif (NOT TARGET lcov-capture)


# This function will add capture of coverage data for target <TNAME>, which is
# needed to get also data for objects, which were not loaded at execution time.
# It will call geninfo for every source file of <TNAME> once and store the info
# file in the same directory.
function (lcov_capture_tgt TNAME)
	# We don't have to check, if the target has support for coverage, thus this
	# will be checked by add_coverage_target in Findcoverage.cmake. Instead we
	# have to determine which gcov binary to use.
	get_target_property(TSOURCES ${TNAME} SOURCES)
	set(SOURCES "")
	set(TCOMPILER "")
	foreach (FILE ${TSOURCES})
		codecov_path_of_source(${FILE} FILE)
		if (NOT "${FILE}" STREQUAL "")
			codecov_lang_of_source(${FILE} LANG)
			if (NOT "${LANG}" STREQUAL "")
				list(APPEND SOURCES "${FILE}")
				set(TCOMPILER ${CMAKE_${LANG}_COMPILER_ID})
			endif ()
		endif ()
	endforeach ()

	# If no gcov binary was found, coverage data can't be evaluated.
	if (NOT GCOV_${TCOMPILER}_BIN)
		message(WARNING "No coverage evaluation binary found for ${TCOMPILER}.")
		return()
	endif ()

	set(GCOV_BIN "${GCOV_${TCOMPILER}_BIN}")
	set(GCOV_ENV "${GCOV_${TCOMPILER}_ENV}")


	set(TDIR ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${TNAME}.dir)
	set(GENINFO_FILES "")
	foreach(FILE ${SOURCES})
		# Generate coverage files. If no .gcda file was generated during
		# execution, the empty coverage file will be used instead.
		set(OUTFILE "${TDIR}/${FILE}.info")
		list(APPEND GENINFO_FILES ${OUTFILE})

		add_custom_command(OUTPUT ${OUTFILE}
			COMMAND test -f "${TDIR}/${FILE}.gcda"
				&& ${GCOV_ENV} ${GENINFO_BIN} --quiet --base-directory
					${PROJECT_SOURCE_DIR} --gcov-tool ${GCOV_BIN}
					--output-filename ${OUTFILE} ${GENINFO_EXTERN_FLAG}
					${TDIR}/${FILE}.gcda
				|| cp ${OUTFILE}.init ${OUTFILE}
			DEPENDS ${TNAME} ${TNAME}-capture-init
			COMMENT "Capturing coverage data for ${FILE}"
		)
	endforeach()

	# Concatenate all files generated by geninfo to a single file per target.
	set(OUTFILE "${LCOV_DATA_PATH_CAPTURE}/${TNAME}.info")
	lcov_merge_files("${OUTFILE}" ${GENINFO_FILES})
	add_custom_target(${TNAME}-geninfo DEPENDS ${OUTFILE})

	# add geninfo file generation to global lcov-capture target
	add_dependencies(lcov-capture ${TNAME}-geninfo)
	set(LCOV_CAPTURE_FILES "${LCOV_CAPTURE_FILES}" "${OUTFILE}" CACHE INTERNAL
		""
	)

	# Add target for generating html output for this target only.
	file(MAKE_DIRECTORY ${LCOV_HTML_PATH}/${TNAME})
	add_custom_target(${TNAME}-genhtml
		COMMAND ${GENHTML_BIN} --quiet --sort --prefix ${PROJECT_SOURCE_DIR}
			--baseline-file ${LCOV_DATA_PATH_INIT}/${TNAME}.info
			--output-directory ${LCOV_HTML_PATH}/${TNAME}
			--title "${CMAKE_PROJECT_NAME} - target ${TNAME}"
			${GENHTML_CPPFILT_FLAG} ${OUTFILE}
		DEPENDS ${TNAME}-geninfo ${TNAME}-capture-init
	)
endfunction (lcov_capture_tgt)


# This function will generate the global info file for all targets. It has to be
# called after all other CMake functions in the root CMakeLists.txt file, to get
# a full list of all targets that generate coverage data.
function (lcov_capture)
	# Skip this function (and do not create the following targets), if there are
	# no input files.
	if ("${LCOV_CAPTURE_FILES}" STREQUAL "")
		return()
	endif ()

	# Add a new target to merge the files of all targets.
	set(OUTFILE "${LCOV_DATA_PATH_CAPTURE}/all_targets.info")
	lcov_merge_files("${OUTFILE}" ${LCOV_CAPTURE_FILES})
	add_custom_target(lcov-geninfo DEPENDS ${OUTFILE} lcov-capture)

	# Add a new global target for all lcov targets. This target could be used to
	# generate the lcov html output for the whole project instead of calling
	# <TARGET>-geninfo and <TARGET>-genhtml for each target. It will also be
	# used to generate a html site for all project data together instead of one
	# for each target.
	if (NOT TARGET lcov)
		file(MAKE_DIRECTORY ${LCOV_HTML_PATH}/all_targets)
		add_custom_target(lcov
			COMMAND ${GENHTML_BIN} --quiet --sort
				--baseline-file ${LCOV_DATA_PATH_INIT}/all_targets.info
				--output-directory ${LCOV_HTML_PATH}/all_targets
				--title "${CMAKE_PROJECT_NAME}" --prefix "${PROJECT_SOURCE_DIR}"
				${GENHTML_CPPFILT_FLAG} ${OUTFILE}
			DEPENDS lcov-geninfo-init lcov-geninfo
		)
	endif ()
endfunction (lcov_capture)




# Add a new global target to generate the lcov html report for the whole project
# instead of calling <TARGET>-genhtml for each target (to create an own report
# for each target). Instead of the lcov target it does not require geninfo for
# all targets, so you have to call <TARGET>-geninfo to generate the info files
# the targets you'd like to have in your report or lcov-geninfo for generating
# info files for all targets before calling lcov-genhtml.
file(MAKE_DIRECTORY ${LCOV_HTML_PATH}/selected_targets)
if (NOT TARGET lcov-genhtml)
	add_custom_target(lcov-genhtml
		COMMAND ${GENHTML_BIN}
			--quiet
			--output-directory ${LCOV_HTML_PATH}/selected_targets
			--title \"${CMAKE_PROJECT_NAME} - targets  `find
				${LCOV_DATA_PATH_CAPTURE} -name \"*.info\" ! -name
				\"all_targets.info\" -exec basename {} .info \\\;`\"
			--prefix ${PROJECT_SOURCE_DIR}
			--sort
			${GENHTML_CPPFILT_FLAG}
			`find ${LCOV_DATA_PATH_CAPTURE} -name \"*.info\" ! -name
				\"all_targets.info\"`
	)
endif (NOT TARGET lcov-genhtml)


================================================
FILE: CMake/Findcodecov.cmake
================================================
# This file is part of CMake-codecov.
#
# Copyright (c)
#   2015-2017 RWTH Aachen University, Federal Republic of Germany
#
# See the LICENSE file in the package base directory for details
#
# Written by Alexander Haase, alexander.haase@rwth-aachen.de
#


# Add an option to choose, if coverage should be enabled or not. If enabled
# marked targets will be build with coverage support and appropriate targets
# will be added. If disabled coverage will be ignored for *ALL* targets.
option(ENABLE_COVERAGE "Enable coverage build." OFF)

set(COVERAGE_FLAG_CANDIDATES
	# gcc and clang
	"-O0 -g -fprofile-arcs -ftest-coverage"

	# gcc and clang fallback
	"-O0 -g --coverage"
)


# Add coverage support for target ${TNAME} and register target for coverage
# evaluation. If coverage is disabled or not supported, this function will
# simply do nothing.
#
# Note: This function is only a wrapper to define this function always, even if
#   coverage is not supported by the compiler or disabled. This function must
#   be defined here, because the module will be exited, if there is no coverage
#   support by the compiler or it is disabled by the user.
function (add_coverage TNAME)
	# only add coverage for target, if coverage is support and enabled.
	if (ENABLE_COVERAGE)
		foreach (TNAME ${ARGV})
			add_coverage_target(${TNAME})
		endforeach ()
	endif ()
endfunction (add_coverage)


# Add global target to gather coverage information after all targets have been
# added. Other evaluation functions could be added here, after checks for the
# specific module have been passed.
#
# Note: This function is only a wrapper to define this function always, even if
#   coverage is not supported by the compiler or disabled. This function must
#   be defined here, because the module will be exited, if there is no coverage
#   support by the compiler or it is disabled by the user.
function (coverage_evaluate)
	# add lcov evaluation
	if (LCOV_FOUND)
		lcov_capture_initial()
		lcov_capture()
	endif (LCOV_FOUND)
endfunction ()


# Exit this module, if coverage is disabled. add_coverage is defined before this
# return, so this module can be exited now safely without breaking any build-
# scripts.
if (NOT ENABLE_COVERAGE)
	return()
endif ()




# Find the reuired flags foreach language.
set(CMAKE_REQUIRED_QUIET_SAVE ${CMAKE_REQUIRED_QUIET})
set(CMAKE_REQUIRED_QUIET ${codecov_FIND_QUIETLY})

get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
foreach (LANG ${ENABLED_LANGUAGES})
	# Coverage flags are not dependend on language, but the used compiler. So
	# instead of searching flags foreach language, search flags foreach compiler
	# used.
	set(COMPILER ${CMAKE_${LANG}_COMPILER_ID})
	if (NOT COVERAGE_${COMPILER}_FLAGS)
		foreach (FLAG ${COVERAGE_FLAG_CANDIDATES})
			if(NOT CMAKE_REQUIRED_QUIET)
				message(STATUS "Try ${COMPILER} code coverage flag = [${FLAG}]")
			endif()

			set(CMAKE_REQUIRED_FLAGS "${FLAG}")
			unset(COVERAGE_FLAG_DETECTED CACHE)

			if (${LANG} STREQUAL "C")
				include(CheckCCompilerFlag)
				check_c_compiler_flag("${FLAG}" COVERAGE_FLAG_DETECTED)

			elseif (${LANG} STREQUAL "CXX")
				include(CheckCXXCompilerFlag)
				check_cxx_compiler_flag("${FLAG}" COVERAGE_FLAG_DETECTED)

			elseif (${LANG} STREQUAL "Fortran")
				# CheckFortranCompilerFlag was introduced in CMake 3.x. To be
				# compatible with older Cmake versions, we will check if this
				# module is present before we use it. Otherwise we will define
				# Fortran coverage support as not available.
				include(CheckFortranCompilerFlag OPTIONAL
					RESULT_VARIABLE INCLUDED)
				if (INCLUDED)
					check_fortran_compiler_flag("${FLAG}"
						COVERAGE_FLAG_DETECTED)
				elseif (NOT CMAKE_REQUIRED_QUIET)
					message("-- Performing Test COVERAGE_FLAG_DETECTED")
					message("-- Performing Test COVERAGE_FLAG_DETECTED - Failed"
						" (Check not supported)")
				endif ()
			endif()

			if (COVERAGE_FLAG_DETECTED)
				set(COVERAGE_${COMPILER}_FLAGS "${FLAG}"
					CACHE STRING "${COMPILER} flags for code coverage.")
				mark_as_advanced(COVERAGE_${COMPILER}_FLAGS)
				break()
			else ()
				message(WARNING "Code coverage is not available for ${COMPILER}"
				        " compiler. Targets using this compiler will be "
				        "compiled without it.")
			endif ()
		endforeach ()
	endif ()
endforeach ()

set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE})




# Helper function to get the language of a source file.
function (codecov_lang_of_source FILE RETURN_VAR)
	get_filename_component(FILE_EXT "${FILE}" EXT)
	string(TOLOWER "${FILE_EXT}" FILE_EXT)
	string(SUBSTRING "${FILE_EXT}" 1 -1 FILE_EXT)

	get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
	foreach (LANG ${ENABLED_LANGUAGES})
		list(FIND CMAKE_${LANG}_SOURCE_FILE_EXTENSIONS "${FILE_EXT}" TEMP)
		if (NOT ${TEMP} EQUAL -1)
			set(${RETURN_VAR} "${LANG}" PARENT_SCOPE)
			return()
		endif ()
	endforeach()

	set(${RETURN_VAR} "" PARENT_SCOPE)
endfunction ()


# Helper function to get the relative path of the source file destination path.
# This path is needed by FindGcov and FindLcov cmake files to locate the
# captured data.
function (codecov_path_of_source FILE RETURN_VAR)
	string(REGEX MATCH "TARGET_OBJECTS:([^ >]+)" _source ${FILE})

	# If expression was found, SOURCEFILE is a generator-expression for an
	# object library. Currently we found no way to call this function automatic
	# for the referenced target, so it must be called in the directoryso of the
	# object library definition.
	if (NOT "${_source}" STREQUAL "")
		set(${RETURN_VAR} "" PARENT_SCOPE)
		return()
	endif ()


	string(REPLACE "${CMAKE_CURRENT_BINARY_DIR}/" "" FILE "${FILE}")
	if(IS_ABSOLUTE ${FILE})
		file(RELATIVE_PATH FILE ${CMAKE_CURRENT_SOURCE_DIR} ${FILE})
	endif()

	# get the right path for file
	string(REPLACE ".." "__" PATH "${FILE}")

	set(${RETURN_VAR} "${PATH}" PARENT_SCOPE)
endfunction()




# Add coverage support for target ${TNAME} and register target for coverage
# evaluation.
function(add_coverage_target TNAME)
	# Check if all sources for target use the same compiler. If a target uses
	# e.g. C and Fortran mixed and uses different compilers (e.g. clang and
	# gfortran) this can trigger huge problems, because different compilers may
	# use different implementations for code coverage.
	get_target_property(TSOURCES ${TNAME} SOURCES)
	set(TARGET_COMPILER "")
	set(ADDITIONAL_FILES "")
	foreach (FILE ${TSOURCES})
		# If expression was found, FILE is a generator-expression for an object
		# library. Object libraries will be ignored.
		string(REGEX MATCH "TARGET_OBJECTS:([^ >]+)" _file ${FILE})
		if ("${_file}" STREQUAL "")
			codecov_lang_of_source(${FILE} LANG)
			if (LANG)
				list(APPEND TARGET_COMPILER ${CMAKE_${LANG}_COMPILER_ID})

				list(APPEND ADDITIONAL_FILES "${FILE}.gcno")
				list(APPEND ADDITIONAL_FILES "${FILE}.gcda")
			endif ()
		endif ()
	endforeach ()

	list(REMOVE_DUPLICATES TARGET_COMPILER)
	list(LENGTH TARGET_COMPILER NUM_COMPILERS)

	if (NUM_COMPILERS GREATER 1)
		message(WARNING "Can't use code coverage for target ${TNAME}, because "
		        "it will be compiled by incompatible compilers. Target will be "
		        "compiled without code coverage.")
		return()

	elseif (NUM_COMPILERS EQUAL 0)
		message(WARNING "Can't use code coverage for target ${TNAME}, because "
		        "it uses an unknown compiler. Target will be compiled without "
		        "code coverage.")
		return()

	elseif (NOT DEFINED "COVERAGE_${TARGET_COMPILER}_FLAGS")
		# A warning has been printed before, so just return if flags for this
		# compiler aren't available.
		return()
	endif()


	# enable coverage for target
	set_property(TARGET ${TNAME} APPEND_STRING
		PROPERTY COMPILE_FLAGS " ${COVERAGE_${TARGET_COMPILER}_FLAGS}")
	set_property(TARGET ${TNAME} APPEND_STRING
		PROPERTY LINK_FLAGS " ${COVERAGE_${TARGET_COMPILER}_FLAGS}")


	# Add gcov files generated by compiler to clean target.
	set(CLEAN_FILES "")
	foreach (FILE ${ADDITIONAL_FILES})
		codecov_path_of_source(${FILE} FILE)
		list(APPEND CLEAN_FILES "CMakeFiles/${TNAME}.dir/${FILE}")
	endforeach()

	set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES
		"${CLEAN_FILES}")


	add_gcov_target(${TNAME})
	add_lcov_target(${TNAME})
endfunction(add_coverage_target)




# Include modules for parsing the collected data and output it in a readable
# format (like gcov and lcov).
find_package(Gcov)
find_package(Lcov)


================================================
FILE: CMake/llvm-cov-wrapper
================================================
#!/bin/sh

# This file is part of CMake-codecov.
#
# Copyright (c)
#   2015-2017 RWTH Aachen University, Federal Republic of Germany
#
# See the LICENSE file in the package base directory for details
#
# Written by Alexander Haase, alexander.haase@rwth-aachen.de
#

if [ -z "$LLVM_COV_BIN" ]
then
	echo "LLVM_COV_BIN not set!" >& 2
	exit 1
fi


# Get LLVM version to find out.
LLVM_VERSION=$($LLVM_COV_BIN -version | grep -i "LLVM version" \
	| sed "s/^\([A-Za-z ]*\)\([0-9]\).\([0-9]\).*$/\2.\3/g")

if [ "$1" = "-v" ]
then
	echo "llvm-cov-wrapper $LLVM_VERSION"
	exit 0
fi


if [ -n "$LLVM_VERSION" ]
then
	MAJOR=$(echo $LLVM_VERSION | cut -d'.' -f1)
	MINOR=$(echo $LLVM_VERSION | cut -d'.' -f2)

	if [ $MAJOR -eq 3 ] && [ $MINOR -le 4 ]
	then
		if [ -f "$1" ]
		then
			filename=$(basename "$1")
			extension="${filename##*.}"

			case "$extension" in
				"gcno") exec $LLVM_COV_BIN --gcno="$1" ;;
				"gcda") exec $LLVM_COV_BIN --gcda="$1" ;;
			esac
		fi
	fi

	if [ $MAJOR -eq 3 ] && [ $MINOR -le 5 ]
	then
		exec $LLVM_COV_BIN $@
	fi
fi

exec $LLVM_COV_BIN gcov $@


================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.8.2)
project(Clara)

set(SOURCE_FILES src/main.cpp src/ClaraTests.cpp include/clara.hpp)
include_directories( include third_party )
add_executable(ClaraTests ${SOURCE_FILES})

if(USE_CPP14)
    set_property(TARGET ClaraTests PROPERTY CXX_STANDARD 14)
    message(STATUS "Enabled C++14")
elseif(USE_CPP17)
    set_property(TARGET ClaraTests PROPERTY CXX_STANDARD 17)
    message(STATUS "Enabled C++17")
else(USE_CPP11)
    set_property(TARGET ClaraTests PROPERTY CXX_STANDARD 11)
    message(STATUS "Enabled C++11")
endif()

set_property(TARGET ClaraTests PROPERTY CXX_STANDARD_REQUIRED ON)
set_property(TARGET ClaraTests PROPERTY CXX_EXTENSIONS OFF)


if( CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang|GNU" )
    target_compile_options( ClaraTests PRIVATE -Wall -Wextra -pedantic -Werror )
endif()
if( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
	target_compile_options( ClaraTests PRIVATE /W4 /WX )
endif()

if (ENABLE_COVERAGE)
    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
    find_package(codecov)
    add_coverage(ClaraTests)
    list(APPEND LCOV_REMOVE_PATTERNS "/usr/")
    coverage_evaluate()
endif()

include(CTest)
add_test(NAME RunTests COMMAND $<TARGET_FILE:ClaraTests>)


================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct

## Our Pledge

In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.

## Our Standards

Examples of behavior that contributes to creating a positive environment include:

* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members

Examples of unacceptable behavior by participants include:

* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting

## Our Responsibilities

Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.

Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.

## Scope

This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at clara@philnash.me. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.

Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]

[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/


================================================
FILE: LICENSE.txt
================================================
Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.


================================================
FILE: README.md
================================================
# Clara v1.1.5
[![Build Status](https://travis-ci.org/catchorg/Clara.svg?branch=master)](https://travis-ci.org/catchorg/Clara)
[![Build status](https://ci.appveyor.com/api/projects/status/github/catchorg/Clara?brach=master&svg=true)](https://ci.appveyor.com/project/catchorg/clara)
[![codecov](https://codecov.io/gh/catchorg/Clara/branch/master/graph/badge.svg)](https://codecov.io/gh/catchorg/Clara)

# !! This repository is unmaintained. Go [here](https://github.com/bfgroup/Lyra) for a fork that is somewhat maintained. !!

-----------------------------


A simple to use, composable, command line parser for C++ 11 and beyond.

Clara is a single-header library.

To use, just `#include "clara.hpp"`

A parser for a single option can be created like this:

```c++
int width = 0;
// ...
using namespace clara;
auto cli
    = Opt( width, "width" )
        ["-w"]["--width"]
        ("How wide should it be?");
```

You can use this parser directly like this:

```c++
auto result = cli.parse( Args( argc, argv ) );
if( !result ) {
    std::cerr << "Error in command line: " << result.errorMessage() << std::endl;
    exit(1);
}

// Everything was ok, width will have a value if supplied on command line
```

Note that exceptions are not used for error handling.

You can combine parsers by composing with `|`, like this:

```c++
int width = 0;
std::string name;
bool doIt = false;
std::string command;
auto cli
    = Opt( width, "width" )
        ["-w"]["--width"]
        ("How wide should it be?")
    | Opt( name, "name" )
        ["-n"]["--name"]
        ("By what name should I be known")
    | Opt( doIt )
        ["-d"]["--doit"]
        ("Do the thing" )
    | Arg( command, "command" )
        ("which command to run");
```

`Opt`s specify options that start with a short dash (`-`) or long dash (`--`).
On Windows forward slashes are also accepted (and automatically interpretted as a short dash).
Options can be argument taking (such as `-w 42`), in which case the `Opt` takes a second argument - a hint,
or they are pure flags (such as `-d`), in which case the `Opt` has only one argument - which must be a boolean.
The option names are provided in one or more sets of square brackets, and a description string can
be provided in parentheses. The first argument to an `Opt` is any variable, local, global member, of any type
that can be converted from a string using `std::ostream`.

`Arg`s specify arguments that are not tied to options, and so have no square bracket names. They otherwise work just like `Opt`s.

A, console optimised, usage string can be obtained by inserting the parser into a stream.
The usage string is built from the information supplied and is formatted for the console width.

As a convenience, the standard help options (`-h`, `--help` and `-?`) can be specified using the `Help` parser,
which just takes a boolean to bind to.

For more usage please see the unit tests or look at how it is used in the Catch code-base (catch-lib.net).
Fuller documentation will be coming soon.

Some of the key features:

- A single header file with no external dependencies (except the std library).
- Define your interface once to get parsing, type conversions and usage strings with no redundancy.
- Composable. Each `Opt` or `Arg` is an independent parser. Combine these to produce a composite parser - this can be done in stages across multiple function calls - or even projects.
- Bind parsers directly to variables that will receive the results of the parse - no intermediate dictionaries to worry about.
- Or can also bind parsers to lambdas for more custom handling.
- Deduces types from bound variables or lambdas and performs type conversions (via `ostream <<`), with error handling, behind the scenes.
- Bind parsers to vectors for args that can have multiple values.
- Uses Result types for error propagation, rather than exceptions (doesn't yet build with exceptions disabled, but that will be coming later)
- Models POSIX standards for short and long opt behaviour.

## Roadmap

To see which direction Clara is going in, please see [the roadmap](Roadmap.md)

## Old version

If you used the earlier, v0.x, version of Clara please note that this is a complete rewrite which assumes C++11 and has
a different interface (composability was a big step forward). Conversion between v0.x and v1.x is a fairly simple and mechanical task, but is a bit of manual
work - so don't take this version until you're ready (and, of course, able to use C++11).

I hope you'll find the new interface an improvement - and this will be built on to offer new features moving forwards.
I don't expect to maintain v0.x any further, but it remains on a branch.


================================================
FILE: Roadmap.md
================================================
# Roadmap

## June 2019 Update

Previously this roadmap said, "I'm not quite ready to throw development fully open to the community effort". The intention had been to clarify the direction in the codebase in some key areas, as many of the PRs were taking it in different directions.

Unfortunuately the time intended for working on this has not appeared and this project has languished in neglect as a result. I should have acknowledged that sooner, but as of now I (@philsquared), am opening this up fully to the community (anyone who is still interested). That means, of course, that maintainers such as @horenmar, will be able to merge PRs as they see fit (as well as make any other changes). It also means that we'd be keen to hear from anyone that wants to take the lead in maintaining and evolving the library.

Personally, I still hope to contribute further to the project, but am no longer in a position I can commit to leading it.

Here are the items I had on the original roadmap, for reference. It is not a hard requirement to follow them:

- Add more documentation (includes [#49](https://github.com/catchorg/Clara/issues/49))
- Finish work on "required" parsers [#39](https://github.com/catchorg/Clara/issues/39), [#16](https://github.com/catchorg/Clara/issues/16) & [PR #28](https://github.com/catchorg/Clara/pull/28)
- Finish work on removing exceptions completely (or making them "optional")
- (compiler conditional) Support for `std::optional` and maybe other optional types (e.g. boost) [#4](https://github.com/catchorg/Clara/issues/4) & [PR #45](https://github.com/catchorg/Clara/pull/45) - this is mostly, if not entirely, implemented. Should be checked, and #4 closed if so.
- Arg\[0] support on Windows [#29](https://github.com/catchorg/Clara/issues/29)
- config files and environment variables
- "hidden" options [#29](https://github.com/catchorg/Clara/issues/29)
- Capture general text for help output [#48]((https://github.com/catchorg/Clara/issues/48)
- subcommands [#31](https://github.com/catchorg/Clara/issues/31) (I actually have a design mostly done for this) - but see also [PR #32](https://github.com/catchorg/Clara/pull/32)

---



================================================
FILE: appveyor.yml
================================================
version: "{build}"

branches:
  except:
    - /dev-travis.+/

os:
  - Visual Studio 2017
  - Visual Studio 2015

environment:
    matrix:
        - additional_flags: "/permissive- /std:c++latest"
        - additional_flags: ""

matrix:
    exclude:
        - os: Visual Studio 2015
          additional_flags: "/permissive- /std:c++latest"

init:
  - git config --global core.autocrlf input

install:
  - ps: if (($env:CONFIGURATION) -eq "Debug" ) { python -m pip --disable-pip-version-check install codecov }
  - ps: if (($env:CONFIGURATION) -eq "Debug" ) { .\misc\installOpenCppCoverage.ps1 }

# Win32 and x64 are CMake-compatible solution platform names.
# This allows us to pass %PLATFORM% to CMake -A.
platform:
  - Win32
  - x64

# build Configurations, i.e. Debug, Release, etc.
configuration:
  - Debug
  - Release

#Cmake will autodetect the compiler, but we set the arch
before_build:
  - set CXXFLAGS=%additional_flags%
  # Indirection because appveyor doesn't handle multiline batch scripts properly
  # https://stackoverflow.com/questions/37627248/how-to-split-a-command-over-multiple-lines-in-appveyor-yml/37647169#37647169
  # https://help.appveyor.com/discussions/questions/3888-multi-line-cmd-or-powershell-warning-ignore
  - cmd: .\misc\appveyorBuildConfigurationScript.bat

  
# build with MSBuild
build:
  project: Build\Clara.sln              # path to Visual Studio solution or project
  parallel: true                        # enable MSBuild parallel builds
  verbosity: normal                     # MSBuild verbosity level {quiet|minimal|normal|detailed}

test_script:
  - set CTEST_OUTPUT_ON_FAILURE=1
  - cmd: .\misc\appveyorTestRunScript.bat


================================================
FILE: codecov.yml
================================================
codecov:
  branch: master

coverage:
  ignore:
    - "src/*"
    - "third_party/catch.hpp"


================================================
FILE: docs/release-notes.md
================================================
<a id="top"></a>

# 1.1.3

## Improvements
* `Args` now take arguments as `int argc, char const * const * argv`.
  * This allows the use of string literals for arguments


# 1.1.2
* Fix usage of `dynamic_cast` preventing Clara being used with `-fno-rtti`


# Older versions (1.1.1 and earlier)

No release notes have been kept (Maybe some of it will be backfilled later)


================================================
FILE: include/clara.hpp
================================================
// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See https://github.com/philsquared/Clara for more details

// Clara v1.1.5

#ifndef CLARA_HPP_INCLUDED
#define CLARA_HPP_INCLUDED

#ifndef CLARA_CONFIG_CONSOLE_WIDTH
#define CLARA_CONFIG_CONSOLE_WIDTH 80
#endif

#ifndef CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
#define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
#endif

#ifndef CLARA_CONFIG_OPTIONAL_TYPE
#   ifdef __has_include
#       if __has_include(<optional>) && __cplusplus >= 201703L
#           include <optional>
#           define CLARA_CONFIG_OPTIONAL_TYPE std::optional
#       endif
#   endif
#endif

#include "clara_textflow.hpp"

#include <cctype>
#include <vector>
#include <memory>
#include <sstream>
#include <cassert>
#include <set>
#include <algorithm>

#if !defined(CLARA_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
#define CLARA_PLATFORM_WINDOWS
#endif

namespace clara {
namespace detail {

    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
    template<typename L>
    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};

    template<typename ClassT, typename ReturnT, typename... Args>
    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
        static const bool isValid = false;
    };

    template<typename ClassT, typename ReturnT, typename ArgT>
    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
        static const bool isValid = true;
        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
        using ReturnType = ReturnT;
    };

    class TokenStream;

    // Transport for raw args (copied from main args, or supplied via init list for testing)
    class Args {
        friend TokenStream;
        std::string m_exeName;
        std::vector<std::string> m_args;

    public:
        Args( int argc, char const* const* argv )
            : m_exeName(argv[0]),
              m_args(argv + 1, argv + argc) {}

        Args( std::initializer_list<std::string> args )
        :   m_exeName( *args.begin() ),
            m_args( args.begin()+1, args.end() )
        {}

        auto exeName() const -> std::string {
            return m_exeName;
        }
    };

    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
    // may encode an option + its argument if the : or = form is used
    enum class TokenType {
        Option, Argument
    };
    struct Token {
        TokenType type;
        std::string token;
    };

    inline auto isOptPrefix( char c ) -> bool {
        return c == '-'
#ifdef CLARA_PLATFORM_WINDOWS
            || c == '/'
#endif
        ;
    }

    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
    class TokenStream {
        using Iterator = std::vector<std::string>::const_iterator;
        Iterator it;
        Iterator itEnd;
        std::vector<Token> m_tokenBuffer;

        void loadBuffer() {
            m_tokenBuffer.resize( 0 );

            // Skip any empty strings
            while( it != itEnd && it->empty() )
                ++it;

            if( it != itEnd ) {
                auto const &next = *it;
                if( isOptPrefix( next[0] ) ) {
                    auto delimiterPos = next.find_first_of( " :=" );
                    if( delimiterPos != std::string::npos ) {
                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
                    } else {
                        if( next[1] != '-' && next.size() > 2 ) {
                            std::string opt = "- ";
                            for( size_t i = 1; i < next.size(); ++i ) {
                                opt[1] = next[i];
                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
                            }
                        } else {
                            m_tokenBuffer.push_back( { TokenType::Option, next } );
                        }
                    }
                } else {
                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
                }
            }
        }

    public:
        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}

        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
            loadBuffer();
        }

        explicit operator bool() const {
            return !m_tokenBuffer.empty() || it != itEnd;
        }

        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }

        auto operator*() const -> Token {
            assert( !m_tokenBuffer.empty() );
            return m_tokenBuffer.front();
        }

        auto operator->() const -> Token const * {
            assert( !m_tokenBuffer.empty() );
            return &m_tokenBuffer.front();
        }

        auto operator++() -> TokenStream & {
            if( m_tokenBuffer.size() >= 2 ) {
                m_tokenBuffer.erase( m_tokenBuffer.begin() );
            } else {
                if( it != itEnd )
                    ++it;
                loadBuffer();
            }
            return *this;
        }
    };


    class ResultBase {
    public:
        enum Type {
            Ok, LogicError, RuntimeError
        };

    protected:
        ResultBase( Type type ) : m_type( type ) {}
        virtual ~ResultBase() = default;

        virtual void enforceOk() const = 0;

        Type m_type;
    };

    template<typename T>
    class ResultValueBase : public ResultBase {
    public:
        auto value() const -> T const & {
            enforceOk();
            return m_value;
        }

    protected:
        ResultValueBase( Type type ) : ResultBase( type ) {}

        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
            if( m_type == ResultBase::Ok )
                new( &m_value ) T( other.m_value );
        }

        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
            new( &m_value ) T( value );
        }

        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
            if( m_type == ResultBase::Ok )
                m_value.~T();
            ResultBase::operator=(other);
            if( m_type == ResultBase::Ok )
                new( &m_value ) T( other.m_value );
            return *this;
        }

        ~ResultValueBase() override {
            if( m_type == Ok )
                m_value.~T();
        }

        union {
            T m_value;
        };
    };

    template<>
    class ResultValueBase<void> : public ResultBase {
    protected:
        using ResultBase::ResultBase;
    };

    template<typename T = void>
    class BasicResult : public ResultValueBase<T> {
    public:
        template<typename U>
        explicit BasicResult( BasicResult<U> const &other )
        :   ResultValueBase<T>( other.type() ),
            m_errorMessage( other.errorMessage() )
        {
            assert( type() != ResultBase::Ok );
        }

        template<typename U>
        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }

        explicit operator bool() const { return m_type == ResultBase::Ok; }
        auto type() const -> ResultBase::Type { return m_type; }
        auto errorMessage() const -> std::string { return m_errorMessage; }

    protected:
        void enforceOk() const override {

            // Errors shouldn't reach this point, but if they do
            // the actual error message will be in m_errorMessage
            assert( m_type != ResultBase::LogicError );
            assert( m_type != ResultBase::RuntimeError );
            if( m_type != ResultBase::Ok )
                std::abort();
        }

        std::string m_errorMessage; // Only populated if resultType is an error

        BasicResult( ResultBase::Type type, std::string const &message )
        :   ResultValueBase<T>(type),
            m_errorMessage(message)
        {
            assert( m_type != ResultBase::Ok );
        }

        using ResultValueBase<T>::ResultValueBase;
        using ResultBase::m_type;
    };

    enum class ParseResultType {
        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
    };

    class ParseState {
    public:

        ParseState( ParseResultType type, TokenStream const &remainingTokens )
        : m_type(type),
          m_remainingTokens( remainingTokens )
        {}

        auto type() const -> ParseResultType { return m_type; }
        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }

    private:
        ParseResultType m_type;
        TokenStream m_remainingTokens;
    };

    using Result = BasicResult<void>;
    using ParserResult = BasicResult<ParseResultType>;
    using InternalParseResult = BasicResult<ParseState>;

    struct HelpColumns {
        std::string left;
        std::string right;
    };

    template<typename T>
    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
        std::stringstream ss;
        ss << source;
        ss >> target;
        if( ss.fail() )
            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
        else
            return ParserResult::ok( ParseResultType::Matched );
    }
    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
        target = source;
        return ParserResult::ok( ParseResultType::Matched );
    }
    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
        std::string srcLC = source;
        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
            target = true;
        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
            target = false;
        else
            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
        return ParserResult::ok( ParseResultType::Matched );
    }
#ifdef CLARA_CONFIG_OPTIONAL_TYPE
    template<typename T>
    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
        T temp;
        auto result = convertInto( source, temp );
        if( result )
            target = std::move(temp);
        return result;
    }
#endif // CLARA_CONFIG_OPTIONAL_TYPE

    struct NonCopyable {
        NonCopyable() = default;
        NonCopyable( NonCopyable const & ) = delete;
        NonCopyable( NonCopyable && ) = delete;
        NonCopyable &operator=( NonCopyable const & ) = delete;
        NonCopyable &operator=( NonCopyable && ) = delete;
    };

    struct BoundRef : NonCopyable {
        virtual ~BoundRef() = default;
        virtual auto isContainer() const -> bool { return false; }
        virtual auto isFlag() const -> bool { return false; }
    };
    struct BoundValueRefBase : BoundRef {
        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
    };
    struct BoundFlagRefBase : BoundRef {
        virtual auto setFlag( bool flag ) -> ParserResult = 0;
        virtual auto isFlag() const -> bool { return true; }
    };

    template<typename T>
    struct BoundValueRef : BoundValueRefBase {
        T &m_ref;

        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}

        auto setValue( std::string const &arg ) -> ParserResult override {
            return convertInto( arg, m_ref );
        }
    };

    template<typename T>
    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
        std::vector<T> &m_ref;

        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}

        auto isContainer() const -> bool override { return true; }

        auto setValue( std::string const &arg ) -> ParserResult override {
            T temp;
            auto result = convertInto( arg, temp );
            if( result )
                m_ref.push_back( temp );
            return result;
        }
    };

    struct BoundFlagRef : BoundFlagRefBase {
        bool &m_ref;

        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}

        auto setFlag( bool flag ) -> ParserResult override {
            m_ref = flag;
            return ParserResult::ok( ParseResultType::Matched );
        }
    };

    template<typename ReturnType>
    struct LambdaInvoker {
        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );

        template<typename L, typename ArgType>
        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
            return lambda( arg );
        }
    };

    template<>
    struct LambdaInvoker<void> {
        template<typename L, typename ArgType>
        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
            lambda( arg );
            return ParserResult::ok( ParseResultType::Matched );
        }
    };

    template<typename ArgType, typename L>
    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
        ArgType temp{};
        auto result = convertInto( arg, temp );
        return !result
           ? result
           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
    }


    template<typename L>
    struct BoundLambda : BoundValueRefBase {
        L m_lambda;

        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}

        auto setValue( std::string const &arg ) -> ParserResult override {
            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
        }
    };

    template<typename L>
    struct BoundFlagLambda : BoundFlagRefBase {
        L m_lambda;

        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );

        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}

        auto setFlag( bool flag ) -> ParserResult override {
            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
        }
    };

    enum class Optionality { Optional, Required };

    struct Parser;

    class ParserBase {
    public:
        virtual ~ParserBase() = default;
        virtual auto validate() const -> Result { return Result::ok(); }
        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
        virtual auto cardinality() const -> size_t { return 1; }

        auto parse( Args const &args ) const -> InternalParseResult {
            return parse( args.exeName(), TokenStream( args ) );
        }
    };

    template<typename DerivedT>
    class ComposableParserImpl : public ParserBase {
    public:
        template<typename T>
        auto operator|( T const &other ) const -> Parser;

		template<typename T>
        auto operator+( T const &other ) const -> Parser;
    };

    // Common code and state for Args and Opts
    template<typename DerivedT>
    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
    protected:
        Optionality m_optionality = Optionality::Optional;
        std::shared_ptr<BoundRef> m_ref;
        std::string m_hint;
        std::string m_description;

        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}

    public:
        template<typename T>
        ParserRefImpl( T &ref, std::string const &hint )
        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
            m_hint( hint )
        {}

        template<typename LambdaT>
        ParserRefImpl( LambdaT const &ref, std::string const &hint )
        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
            m_hint(hint)
        {}

        auto operator()( std::string const &description ) -> DerivedT & {
            m_description = description;
            return static_cast<DerivedT &>( *this );
        }

        auto optional() -> DerivedT & {
            m_optionality = Optionality::Optional;
            return static_cast<DerivedT &>( *this );
        };

        auto required() -> DerivedT & {
            m_optionality = Optionality::Required;
            return static_cast<DerivedT &>( *this );
        };

        auto isOptional() const -> bool {
            return m_optionality == Optionality::Optional;
        }

        auto cardinality() const -> size_t override {
            if( m_ref->isContainer() )
                return 0;
            else
                return 1;
        }

        auto hint() const -> std::string { return m_hint; }
    };

    class ExeName : public ComposableParserImpl<ExeName> {
        std::shared_ptr<std::string> m_name;
        std::shared_ptr<BoundValueRefBase> m_ref;

        template<typename LambdaT>
        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
        }

    public:
        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}

        explicit ExeName( std::string &ref ) : ExeName() {
            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
        }

        template<typename LambdaT>
        explicit ExeName( LambdaT const& lambda ) : ExeName() {
            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
        }

        // The exe name is not parsed out of the normal tokens, but is handled specially
        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
        }

        auto name() const -> std::string { return *m_name; }
        auto set( std::string const& newName ) -> ParserResult {

            auto lastSlash = newName.find_last_of( "\\/" );
            auto filename = ( lastSlash == std::string::npos )
                    ? newName
                    : newName.substr( lastSlash+1 );

            *m_name = filename;
            if( m_ref )
                return m_ref->setValue( filename );
            else
                return ParserResult::ok( ParseResultType::Matched );
        }
    };

    class Arg : public ParserRefImpl<Arg> {
    public:
        using ParserRefImpl::ParserRefImpl;

        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
            auto validationResult = validate();
            if( !validationResult )
                return InternalParseResult( validationResult );

            auto remainingTokens = tokens;
            auto const &token = *remainingTokens;
            if( token.type != TokenType::Argument )
                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );

            assert( !m_ref->isFlag() );
            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );

            auto result = valueRef->setValue( remainingTokens->token );
            if( !result )
                return InternalParseResult( result );
            else
                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
        }
    };

    inline auto normaliseOpt( std::string const &optName ) -> std::string {
#ifdef CLARA_PLATFORM_WINDOWS
        if( optName[0] == '/' )
            return "-" + optName.substr( 1 );
        else
#endif
            return optName;
    }

    class Opt : public ParserRefImpl<Opt> {
    protected:
        std::vector<std::string> m_optNames;

    public:
        template<typename LambdaT>
        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}

        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}

        template<typename LambdaT>
        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}

        template<typename T>
        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}

        auto operator[]( std::string const &optName ) -> Opt & {
            m_optNames.push_back( optName );
            return *this;
        }

        auto getHelpColumns() const -> std::vector<HelpColumns> {
            std::ostringstream oss;
            bool first = true;
            for( auto const &opt : m_optNames ) {
                if (first)
                    first = false;
                else
                    oss << ", ";
                oss << opt;
            }
            if( !m_hint.empty() )
                oss << " <" << m_hint << ">";
            return { { oss.str(), m_description } };
        }

        auto isMatch( std::string const &optToken ) const -> bool {
            auto normalisedToken = normaliseOpt( optToken );
            for( auto const &name : m_optNames ) {
                if( normaliseOpt( name ) == normalisedToken )
                    return true;
            }
            return false;
        }

        using ParserBase::parse;

        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
            auto validationResult = validate();
            if( !validationResult )
                return InternalParseResult( validationResult );

            auto remainingTokens = tokens;
            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
                auto const &token = *remainingTokens;
                if( isMatch(token.token ) ) {
                    if( m_ref->isFlag() ) {
                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
                        auto result = flagRef->setFlag( true );
                        if( !result )
                            return InternalParseResult( result );
                        if( result.value() == ParseResultType::ShortCircuitAll )
                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
                    } else {
                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
                        ++remainingTokens;
                        if( !remainingTokens )
                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
                        auto const &argToken = *remainingTokens;
                        if( argToken.type != TokenType::Argument )
                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
                        auto result = valueRef->setValue( argToken.token );
                        if( !result )
                            return InternalParseResult( result );
                        if( result.value() == ParseResultType::ShortCircuitAll )
                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
                    }
                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
                }
            }
            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
        }

        auto validate() const -> Result override {
            if( m_optNames.empty() )
                return Result::logicError( "No options supplied to Opt" );
            for( auto const &name : m_optNames ) {
                if( name.empty() )
                    return Result::logicError( "Option name cannot be empty" );
#ifdef CLARA_PLATFORM_WINDOWS
                if( name[0] != '-' && name[0] != '/' )
                    return Result::logicError( "Option name must begin with '-' or '/'" );
#else
                if( name[0] != '-' )
                    return Result::logicError( "Option name must begin with '-'" );
#endif
            }
            return ParserRefImpl::validate();
        }
    };

    struct Help : Opt {
        Help( bool &showHelpFlag )
        :   Opt([&]( bool flag ) {
                showHelpFlag = flag;
                return ParserResult::ok( ParseResultType::ShortCircuitAll );
            })
        {
            static_cast<Opt &>( *this )
                    ("display usage information")
                    ["-?"]["-h"]["--help"]
                    .optional();
        }
    };


    struct Parser : ParserBase {

        mutable ExeName m_exeName;
        std::vector<Opt> m_options;
        std::vector<Arg> m_args;

        auto operator|=( ExeName const &exeName ) -> Parser & {
            m_exeName = exeName;
            return *this;
        }

        auto operator|=( Arg const &arg ) -> Parser & {
            m_args.push_back(arg);
            return *this;
        }

        auto operator|=( Opt const &opt ) -> Parser & {
            m_options.push_back(opt);
            return *this;
        }

        auto operator|=( Parser const &other ) -> Parser & {
            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
            return *this;
        }

        template<typename T>
        auto operator|( T const &other ) const -> Parser {
            return Parser( *this ) |= other;
        }

        // Forward deprecated interface with '+' instead of '|'
        template<typename T>
        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
        template<typename T>
        auto operator+( T const &other ) const -> Parser { return operator|( other ); }

        auto getHelpColumns() const -> std::vector<HelpColumns> {
            std::vector<HelpColumns> cols;
            for (auto const &o : m_options) {
                auto childCols = o.getHelpColumns();
                cols.insert( cols.end(), childCols.begin(), childCols.end() );
            }
            return cols;
        }

        void writeToStream( std::ostream &os ) const {
            if (!m_exeName.name().empty()) {
                os << "usage:\n" << "  " << m_exeName.name() << " ";
                bool required = true, first = true;
                for( auto const &arg : m_args ) {
                    if (first)
                        first = false;
                    else
                        os << " ";
                    if( arg.isOptional() && required ) {
                        os << "[";
                        required = false;
                    }
                    os << "<" << arg.hint() << ">";
                    if( arg.cardinality() == 0 )
                        os << " ... ";
                }
                if( !required )
                    os << "]";
                if( !m_options.empty() )
                    os << " options";
                os << "\n\nwhere options are:" << std::endl;
            }

            auto rows = getHelpColumns();
            size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
            size_t optWidth = 0;
            for( auto const &cols : rows )
                optWidth = (std::max)(optWidth, cols.left.size() + 2);

            optWidth = (std::min)(optWidth, consoleWidth/2);

            for( auto const &cols : rows ) {
                auto row =
                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
                        TextFlow::Spacer(4) +
                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
                os << row << std::endl;
            }
        }

        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
            parser.writeToStream( os );
            return os;
        }

        auto validate() const -> Result override {
            for( auto const &opt : m_options ) {
                auto result = opt.validate();
                if( !result )
                    return result;
            }
            for( auto const &arg : m_args ) {
                auto result = arg.validate();
                if( !result )
                    return result;
            }
            return Result::ok();
        }

        using ParserBase::parse;

        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {

            struct ParserInfo {
                ParserBase const* parser = nullptr;
                size_t count = 0;
            };
            const size_t totalParsers = m_options.size() + m_args.size();
            assert( totalParsers < 512 );
            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
            ParserInfo parseInfos[512];

            {
                size_t i = 0;
                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
            }

            m_exeName.set( exeName );

            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
            while( result.value().remainingTokens() ) {
                bool tokenParsed = false;

                for( size_t i = 0; i < totalParsers; ++i ) {
                    auto&  parseInfo = parseInfos[i];
                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
                        if (!result)
                            return result;
                        if (result.value().type() != ParseResultType::NoMatch) {
                            tokenParsed = true;
                            ++parseInfo.count;
                            break;
                        }
                    }
                }

                if( result.value().type() == ParseResultType::ShortCircuitAll )
                    return result;
                if( !tokenParsed )
                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
            }
            // !TBD Check missing required options
            return result;
        }
    };

    template<typename DerivedT>
    template<typename T>
    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
        return Parser() | static_cast<DerivedT const &>( *this ) | other;
    }
} // namespace detail


// A Combined parser
using detail::Parser;

// A parser for options
using detail::Opt;

// A parser for arguments
using detail::Arg;

// Wrapper for argc, argv from main()
using detail::Args;

// Specifies the name of the executable
using detail::ExeName;

// Convenience wrapper for option parser that specifies the help option
using detail::Help;

// enum of result types from a parse
using detail::ParseResultType;

// Result type for parser operation
using detail::ParserResult;


} // namespace clara

#endif // CLARA_HPP_INCLUDED


================================================
FILE: include/clara_textflow.hpp
================================================
// TextFlowCpp
//
// A single-header library for wrapping and laying out basic text, by Phil Nash
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// This project is hosted at https://github.com/philsquared/textflowcpp

#ifndef CLARA_TEXTFLOW_HPP_INCLUDED
#define CLARA_TEXTFLOW_HPP_INCLUDED

#include <cassert>
#include <ostream>
#include <sstream>
#include <vector>

#ifndef CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
#define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
#endif


namespace clara { namespace TextFlow {

    inline auto isWhitespace( char c ) -> bool {
        static std::string chars = " \t\n\r";
        return chars.find( c ) != std::string::npos;
    }
    inline auto isBreakableBefore( char c ) -> bool {
        static std::string chars = "[({<|";
        return chars.find( c ) != std::string::npos;
    }
    inline auto isBreakableAfter( char c ) -> bool {
        static std::string chars = "])}>.,:;*+-=&/\\";
        return chars.find( c ) != std::string::npos;
    }

    class Columns;

    class Column {
        std::vector<std::string> m_strings;
        size_t m_width = CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
        size_t m_indent = 0;
        size_t m_initialIndent = std::string::npos;

    public:
        class iterator {
            friend Column;

            Column const& m_column;
            size_t m_stringIndex = 0;
            size_t m_pos = 0;

            size_t m_len = 0;
            size_t m_end = 0;
            bool m_suffix = false;

            iterator( Column const& column, size_t stringIndex )
            :   m_column( column ),
                m_stringIndex( stringIndex )
            {}

            auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }

            auto isBoundary( size_t at ) const -> bool {
                assert( at > 0 );
                assert( at <= line().size() );

                return at == line().size() ||
                       ( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
                       isBreakableBefore( line()[at] ) ||
                       isBreakableAfter( line()[at-1] );
            }

            void calcLength() {
                assert( m_stringIndex < m_column.m_strings.size() );

                m_suffix = false;
                auto width = m_column.m_width-indent();
                m_end = m_pos;
                while( m_end < line().size() && line()[m_end] != '\n' )
                    ++m_end;

                if( m_end < m_pos + width ) {
                    m_len = m_end - m_pos;
                }
                else {
                    size_t len = width;
                    while (len > 0 && !isBoundary(m_pos + len))
                        --len;
                    while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
                        --len;

                    if (len > 0) {
                        m_len = len;
                    } else {
                        m_suffix = true;
                        m_len = width - 1;
                    }
                }
            }

            auto indent() const -> size_t {
                auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
                return initial == std::string::npos ? m_column.m_indent : initial;
            }

            auto addIndentAndSuffix(std::string const &plain) const -> std::string {
                return std::string( indent(), ' ' ) + (m_suffix ? plain + "-" : plain);
            }

        public:
            using difference_type = std::ptrdiff_t;
            using value_type = std::string;
            using pointer = value_type*;
            using reference = value_type&;
            using iterator_category = std::forward_iterator_tag;

            explicit iterator( Column const& column ) : m_column( column ) {
                assert( m_column.m_width > m_column.m_indent );
                assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
                calcLength();
                if( m_len == 0 )
                    m_stringIndex++; // Empty string
            }

            auto operator *() const -> std::string {
                assert( m_stringIndex < m_column.m_strings.size() );
                assert( m_pos <= m_end );
                return addIndentAndSuffix(line().substr(m_pos, m_len));
            }

            auto operator ++() -> iterator& {
                m_pos += m_len;
                if( m_pos < line().size() && line()[m_pos] == '\n' )
                    m_pos += 1;
                else
                    while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
                        ++m_pos;

                if( m_pos == line().size() ) {
                    m_pos = 0;
                    ++m_stringIndex;
                }
                if( m_stringIndex < m_column.m_strings.size() )
                    calcLength();
                return *this;
            }
            auto operator ++(int) -> iterator {
                iterator prev( *this );
                operator++();
                return prev;
            }

            auto operator ==( iterator const& other ) const -> bool {
                return
                    m_pos == other.m_pos &&
                    m_stringIndex == other.m_stringIndex &&
                    &m_column == &other.m_column;
            }
            auto operator !=( iterator const& other ) const -> bool {
                return !operator==( other );
            }
        };
        using const_iterator = iterator;

        explicit Column( std::string const& text ) { m_strings.push_back( text ); }

        auto width( size_t newWidth ) -> Column& {
            assert( newWidth > 0 );
            m_width = newWidth;
            return *this;
        }
        auto indent( size_t newIndent ) -> Column& {
            m_indent = newIndent;
            return *this;
        }
        auto initialIndent( size_t newIndent ) -> Column& {
            m_initialIndent = newIndent;
            return *this;
        }

        auto width() const -> size_t { return m_width; }
        auto begin() const -> iterator { return iterator( *this ); }
        auto end() const -> iterator { return { *this, m_strings.size() }; }

        inline friend std::ostream& operator << ( std::ostream& os, Column const& col ) {
            bool first = true;
            for( auto line : col ) {
                if( first )
                    first = false;
                else
                    os << "\n";
                os <<  line;
            }
            return os;
        }

        auto operator + ( Column const& other ) -> Columns;

        auto toString() const -> std::string {
            std::ostringstream oss;
            oss << *this;
            return oss.str();
        }
    };

    class Spacer : public Column {

    public:
        explicit Spacer( size_t spaceWidth ) : Column( "" ) {
            width( spaceWidth );
        }
    };

    class Columns {
        std::vector<Column> m_columns;

    public:

        class iterator {
            friend Columns;
            struct EndTag {};

            std::vector<Column> const& m_columns;
            std::vector<Column::iterator> m_iterators;
            size_t m_activeIterators;

            iterator( Columns const& columns, EndTag )
            :   m_columns( columns.m_columns ),
                m_activeIterators( 0 )
            {
                m_iterators.reserve( m_columns.size() );

                for( auto const& col : m_columns )
                    m_iterators.push_back( col.end() );
            }

        public:
            using difference_type = std::ptrdiff_t;
            using value_type = std::string;
            using pointer = value_type*;
            using reference = value_type&;
            using iterator_category = std::forward_iterator_tag;

            explicit iterator( Columns const& columns )
            :   m_columns( columns.m_columns ),
                m_activeIterators( m_columns.size() )
            {
                m_iterators.reserve( m_columns.size() );

                for( auto const& col : m_columns )
                    m_iterators.push_back( col.begin() );
            }

            auto operator ==( iterator const& other ) const -> bool {
                return m_iterators == other.m_iterators;
            }
            auto operator !=( iterator const& other ) const -> bool {
                return m_iterators != other.m_iterators;
            }
            auto operator *() const -> std::string {
                std::string row, padding;

                for( size_t i = 0; i < m_columns.size(); ++i ) {
                    auto width = m_columns[i].width();
                    if( m_iterators[i] != m_columns[i].end() ) {
                        std::string col = *m_iterators[i];
                        row += padding + col;
                        if( col.size() < width )
                            padding = std::string( width - col.size(), ' ' );
                        else
                            padding = "";
                    }
                    else {
                        padding += std::string( width, ' ' );
                    }
                }
                return row;
            }
            auto operator ++() -> iterator& {
                for( size_t i = 0; i < m_columns.size(); ++i ) {
                    if (m_iterators[i] != m_columns[i].end())
                        ++m_iterators[i];
                }
                return *this;
            }
            auto operator ++(int) -> iterator {
                iterator prev( *this );
                operator++();
                return prev;
            }
        };
        using const_iterator = iterator;

        auto begin() const -> iterator { return iterator( *this ); }
        auto end() const -> iterator { return { *this, iterator::EndTag() }; }

        auto operator += ( Column const& col ) -> Columns& {
            m_columns.push_back( col );
            return *this;
        }
        auto operator + ( Column const& col ) -> Columns {
            Columns combined = *this;
            combined += col;
            return combined;
        }

        inline friend std::ostream& operator << ( std::ostream& os, Columns const& cols ) {

            bool first = true;
            for( auto line : cols ) {
                if( first )
                    first = false;
                else
                    os << "\n";
                os << line;
            }
            return os;
        }

        auto toString() const -> std::string {
            std::ostringstream oss;
            oss << *this;
            return oss.str();
        }
    };

    inline auto Column::operator + ( Column const& other ) -> Columns {
        Columns cols;
        cols += *this;
        cols += other;
        return cols;
    }
}}

#endif // CLARA_TEXTFLOW_HPP_INCLUDED


================================================
FILE: misc/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.0)

project(ClaraCoverageHelper)

add_executable(CoverageHelper coverage-helper.cpp)
set_property(TARGET CoverageHelper PROPERTY CXX_STANDARD 11)
set_property(TARGET CoverageHelper PROPERTY CXX_STANDARD_REQUIRED ON)
set_property(TARGET CoverageHelper PROPERTY CXX_EXTENSIONS OFF)
if (MSVC)
    target_compile_options( CoverageHelper PRIVATE /W4 /w44265 /w44061 /w44062 )
endif()


================================================
FILE: misc/appveyorBuildConfigurationScript.bat
================================================
@REM  # In debug build, we want to prebuild memcheck redirecter
@REM  # before running the tests
if "%CONFIGURATION%"=="Debug" (
  cmake -Hmisc -Bbuild-misc -A%PLATFORM%
  cmake --build build-misc
  cmake -H. -BBuild -A%PLATFORM% -DMEMORYCHECK_COMMAND=build-misc\Debug\CoverageHelper.exe -DMEMORYCHECK_COMMAND_OPTIONS=--sep-- -DMEMORYCHECK_TYPE=Valgrind
)
if "%CONFIGURATION%"=="Release" (
  cmake -H. -BBuild -A%PLATFORM%
)


================================================
FILE: misc/appveyorMergeCoverageScript.py
================================================
#!/usr/bin/env python2

import glob
import subprocess

if __name__ == '__main__':
    cov_files = list(glob.glob('cov-report*.bin'))
    base_cmd = ['OpenCppCoverage', '--quiet', '--export_type=cobertura:cobertura.xml'] + ['--input_coverage={}'.format(f) for f in cov_files]
    subprocess.call(base_cmd)


================================================
FILE: misc/appveyorTestRunScript.bat
================================================
cd Build
if "%CONFIGURATION%"=="Debug" (
  ctest -j 2 -C %CONFIGURATION% -D ExperimentalMemCheck
  python ..\misc\appveyorMergeCoverageScript.py
  codecov --root .. --no-color --disable gcov -f cobertura.xml -t %CODECOV_TOKEN%
)
if "%CONFIGURATION%"=="Release" (
  ctest -j 2 -C %CONFIGURATION%
)


================================================
FILE: misc/coverage-helper.cpp
================================================
#include <algorithm>
#include <array>
#include <cassert>
#include <cctype>
#include <fstream>
#include <iostream>
#include <memory>
#include <numeric>
#include <regex>
#include <string>
#include <vector>


void create_empty_file(std::string const& path) {
    std::ofstream ofs(path);
    ofs << '\n';
}

const std::string separator = "--sep--";
const std::string logfile_prefix = "--log-file=";
const std::string project_name = "Clara";

std::string to_lower(std::string in) {
    for (auto& c : in) {
        c = std::tolower(c);
    }
    return in;
}

bool starts_with(std::string const& str, std::string const& pref) {
    return str.find(pref) == 0;
}

int parse_log_file_arg(std::string const& arg) {
    assert(starts_with(arg, logfile_prefix) && "Attempting to parse incorrect arg!");
    auto fname = arg.substr(logfile_prefix.size());
    create_empty_file(fname);
    std::regex regex("MemoryChecker\\.(\\d+)\\.log", std::regex::icase);
    std::smatch match;
    if (std::regex_search(fname, match, regex)) {
        return std::stoi(match[1]);
    } else {
        throw std::domain_error("Couldn't find desired expression in string: " + fname);
    }
}

std::string project_path(std::string path) {
    auto start = path.find(project_name);
    if (start == std::string::npos) {
        start = path.find(to_lower(project_name));
    }
    if (start == std::string::npos) {
        throw std::domain_error("Couldn't find project's base path");
    }
    auto end = path.find_first_of("\\/", start);
    return path.substr(0, end);
}

std::string windowsify_path(std::string path) {
    for (auto& c : path) {
        if (c == '/') {
            c = '\\';
        }
    }
    return path;
}

void exec_cmd(std::string const& cmd, int log_num, std::string const& path) {
    std::array<char, 128> buffer;
#if defined(_WIN32)
    auto real_cmd = "OpenCppCoverage --export_type binary:cov-report" + std::to_string(log_num)
        + ".bin --quiet " + "--sources " + path + " --cover_children -- " + cmd;
    std::cout << "=== Marker ===: Cmd: " << real_cmd << '\n';
    std::shared_ptr<FILE> pipe(_popen(real_cmd.c_str(), "r"), _pclose);
#else // Just for testing, in the real world we will always work under WIN32
    (void)log_num; (void)path;
    std::shared_ptr<FILE> pipe(popen(cmd.c_str(), "r"), pclose);
#endif

    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    while (!feof(pipe.get())) {
        if (fgets(buffer.data(), 128, pipe.get()) != nullptr) {
            std::cout << buffer.data();
        }
    }
}

// argv should be:
// [0]: our path
// [1]: "--log-file=<path>"
// [2]: "--sep--"
// [3]+: the actual command

int main(int argc, char** argv) {
    std::vector<std::string> args(argv, argv + argc);
    auto sep = std::find(begin(args), end(args), separator);
    assert(sep - begin(args) == 2 && "Structure differs from expected!");

    auto num = parse_log_file_arg(args[1]);

    auto cmdline = std::accumulate(++sep, end(args), std::string{}, [] (const std::string& lhs, const std::string& rhs) {
        return lhs + ' ' + rhs;
    });

    exec_cmd(cmdline, num, windowsify_path(project_path(args[0])));
}


================================================
FILE: misc/installOpenCppCoverage.ps1
================================================
# Downloads are done from the oficial github release page links
$downloadUrl = "https://github.com/OpenCppCoverage/OpenCppCoverage/releases/download/release-0.9.6.1/OpenCppCoverageSetup-x64-0.9.6.1.exe"
$installerPath = [System.IO.Path]::Combine($Env:USERPROFILE, "Downloads", "OpenCppCoverageSetup.exe")

if(-Not (Test-Path $installerPath)) {
    Write-Host -ForegroundColor White ("Downloading OpenCppCoverage from: " + $downloadUrl)
    Start-FileDownload $downloadUrl -FileName $installerPath
}

Write-Host -ForegroundColor White "About to install OpenCppCoverage..."

$installProcess = (Start-Process $installerPath -ArgumentList '/VERYSILENT' -PassThru -Wait)
if($installProcess.ExitCode -ne 0) {
    throw [System.String]::Format("Failed to install OpenCppCoverage, ExitCode: {0}.", $installProcess.ExitCode)
}

# Assume standard, boring, installation path of ".../Program Files/OpenCppCoverage"
$installPath = [System.IO.Path]::Combine(${Env:ProgramFiles}, "OpenCppCoverage")
$env:Path="$env:Path;$installPath"


================================================
FILE: scripts/embed.py
================================================
import re

preprocessorRe = re.compile( r'\s*#.*' )

fdefineRe = re.compile( r'\s*#\s*define\s*(\S*)\s*\(' ) # #defines that take arguments
defineRe = re.compile( r'\s*#\s*define\s*(\S*)\s+(\S*)' ) # all #defines
undefRe = re.compile( r'\s*#\s*undef\s*(\S*)' ) # all #undefs

ifdefCommonRe = re.compile( r'\s*#\s*if' ) # all #ifdefs
ifdefRe = re.compile( r'\s*#\s*ifdef\s*(\S*)' )
ifndefRe = re.compile( r'\s*#\s*ifndef\s*(\S*)' )
endifRe = re.compile( r'\s*#\s*endif\s*//\s*(.*)' )
elseRe = re.compile( r'\s*#\s*else' )
ifRe = re.compile( r'\s*#\s*if\s+(.*)' )

nsRe = re.compile( r'(\s*\s*namespace\s+)(.+)(\s*{?)' )
nsCloseRe = re.compile( r'(\s*})(\s*\/\/\s*namespace\s+)(.+)(\s*{?)' )


class LineMapper:
    def __init__( self, idMap, outerNamespace ):
        self.idMap = idMap
        self.outerNamespace = outerNamespace

    def replaceId( self, lineNo, id ):
        if not id in self.idMap:
            raise ValueError( "Unrecognised macro identifier: '{0}' on line: {1}".format( id, lineNo ) )
        subst = self.idMap[id]
        if subst == "":
            return id
        else:
            return subst

    # TBD:
    #  #if, #ifdef, comments after #else
    def mapLine( self, lineNo, line ):
        m = ifndefRe.match( line )
        if m:
            return "#ifndef " + self.replaceId( lineNo, m.group(1)) + "\n"
        m = defineRe.match( line )
        if m:
            return "#define " + self.replaceId( lineNo, m.group(1)) + "\n"
        m = endifRe.match( line )
        if m:
            return "#endif // " + self.replaceId( lineNo, m.group(1)) + "\n"
        m = nsRe.match( line )
        if m:
            return "{0}{1} {{ namespace {2}{3}".format( m.group(1), self.outerNamespace, m.group(2), m.group(3))
        m = nsCloseRe.match( line )
        if m:
            return "{0}}}{1}{2}::{3}{4}".format( m.group(1), m.group(2), self.outerNamespace, m.group(3), m.group(4))
        return line

    def mapFile(self, filenameIn, filenameOut ):
        print( "Embedding:\n  {0}\nas:\n  {1}".format( filenameIn, filenameOut ) )
        with open( filenameIn, 'r' ) as f, open( filenameOut, 'w' ) as outf:
            lineNo = 1
            for line in f:
                outf.write( self.mapLine( lineNo, line ) )
                lineNo = lineNo + 1
        print( "Written {0} lines".format( lineNo ) )

================================================
FILE: scripts/embedTextFlow.py
================================================
#!/usr/bin/env python3

# Execute this script any time you import a new copy of textflow into the third_party area
import os
import sys
import embed

rootPath = os.path.dirname(os.path.realpath( os.path.dirname(sys.argv[0])))

filename = os.path.join( rootPath, "third_party", "TextFlow.hpp" )
outfilename = os.path.join( rootPath, "include", "clara_textflow.hpp" )


# Mapping of pre-processor identifiers
idMap = {
   "TEXTFLOW_HPP_INCLUDED": "CLARA_TEXTFLOW_HPP_INCLUDED",
    "TEXTFLOW_CONFIG_CONSOLE_WIDTH": "CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH"
    }

# outer namespace to add
outerNamespace = "clara"

mapper = embed.LineMapper( idMap, outerNamespace )
mapper.mapFile( filename, outfilename )

================================================
FILE: scripts/release.py
================================================
#!/usr/bin/env python

from __future__ import print_function
import os
import sys
import re

rootPath = os.path.dirname(os.path.realpath(os.path.dirname(sys.argv[0])))
claraPath = os.path.join( rootPath, "include/clara.hpp" )
readmePath = os.path.join( rootPath, "README.md" )

versionParser = re.compile( r'\s*\/\/\s*Clara\s+v([0-9]+)\.([0-9]+)(\.([0-9]+)(\-(.*)\.([0-9]*))?)?' )
readmeParser = re.compile( r'\s*#\s*Clara\s+v(.*)' )

warnings = 0

def precheck():
    global warnings
    f = open( claraPath, 'r' )
    lineNo = 0
    for line in f:
        lineNo = lineNo+1
        if "dynamic" in line:
            warnings = warnings + 1
            print( "** Warning: use of dynamic_cast on line {0}!".format(lineNo) )
    f.close()

class Version:
    def __init__(self):
        f = open( claraPath, 'r' )
        for line in f:
            m = versionParser.match( line )
            if m:
                self.majorVersion = int(m.group(1))
                self.minorVersion = int(m.group(2))
                self.patchNumber = int(m.group(4))
                if m.group(6) == None:
                    self.branchName = ""
                else:
                    self.branchName = m.group(6)
                if m.group(7) == None:
                    self.buildNumber = 0
                else:
                    self.buildNumber = int(m.group(7))
        f.close()

    def nonDevelopRelease(self):
        if self.branchName != "":
            self.branchName = ""
            self.buildNumber = 0
    def developBuild(self):
        if self.branchName == "":
            self.branchName = "develop"
            self.buildNumber = 0
        else:
            self.buildNumber = self.buildNumber+1

    def incrementBuildNumber(self):
        self.developBuild()
        self.buildNumber = self.buildNumber+1

    def incrementPatchNumber(self):
        self.nonDevelopRelease()
        self.patchNumber = self.patchNumber+1

    def incrementMinorVersion(self):
        self.nonDevelopRelease()
        self.patchNumber = 0
        self.minorVersion = self.minorVersion+1

    def incrementMajorVersion(self):
        self.nonDevelopRelease()
        self.patchNumber = 0
        self.minorVersion = 0
        self.majorVersion = self.majorVersion+1

    def getVersionString(self):
        versionString = '{0}.{1}.{2}'.format( self.majorVersion, self.minorVersion, self.patchNumber )
        if self.branchName != "":
            versionString = versionString + '-{0}.{1}'.format( self.branchName, self.buildNumber )
        return versionString

    def updateHeader(self):
        f = open( claraPath, 'r' )
        lines = []
        for line in f:
            m = versionParser.match( line )
            if m:
                lines.append( '// Clara v{0}'.format( self.getVersionString() ) )
            else:
                lines.append( line.rstrip() )
        f.close()
        f = open( claraPath, 'w' )
        for line in lines:
            f.write( line + "\n" )

    def updateReadme(self):
        f = open( readmePath, 'r' )
        lines = []
        changed = False
        for line in f:
            m = readmeParser.match( line )
            if m:
                lines.append( '# Clara v{0}'.format( self.getVersionString() ) )
                changed = True
            else:
                lines.append( line.rstrip() )
        f.close()
        if changed:
            f = open( readmePath, 'w' )
            for line in lines:
                f.write( line + "\n" )
        else:
            print( "*** Did not update README" )
def usage():
    print( "\n**** Run with patch|minor|major|dev|verify\n" )
    return 1

if len( sys.argv) == 1:
    exit( usage() )

precheck()

v = Version()
oldV = v.getVersionString()

cmd = sys.argv[1].lower()

if warnings > 0:
    print( "Found {0} issue(s)".format(warnings))
    exit(1)

if cmd == "verify":
    print( "No issues found")
    exit(0)
elif cmd == "patch":
    v.incrementPatchNumber()
elif cmd == "minor":
    v.incrementMinorVersion()
elif cmd == "major":
    v.incrementMajorVersion()
elif cmd == "dev":
    v.developBuild()
else:
    exit( usage() )

v.updateHeader()
v.updateReadme()

print( "Updated clara.hpp and README from {0} to v{1}".format( oldV, v.getVersionString() ) )


================================================
FILE: scripts/stitch.py
================================================
#!/usr/bin/env python

# This is an initial cut of a general header stitching script.
# It is currently hard-coded to work with Clara, but that is purely
# a path thing. The next step is the genericise this further and
# apply it to Catch. There will undoubtedly be issues to fix there.
# After that there are further tweaks to make such as suppressing initial
# comments in stitched headers and adding a single new header block to
# the output file, suppressing conditional blocks where the identifiers
# are known and moving all headers not in conditional blocks to the top
# of the file

import os
import sys
import re
import datetime
import string

preprocessorRe = re.compile( r'\s*#.*' )

includesRe = re.compile( r'\s*#\s*include.*' ) # all #includes
sysIncludesRe = re.compile( r'\s*#\s*include\s*<(.*)>' ) # .e.g #include <vector>
prjIncludesRe = re.compile( r'\s*#\s*include\s*"(.*)"' ) # e.g. #include "myheader.h"

fdefineRe = re.compile( r'\s*#\s*define\s*(\S*)\s*\(' ) # #defines that take arguments
defineRe = re.compile( r'\s*#\s*define\s*(\S*)\s+(\S*)' ) # all #defines
undefRe = re.compile( r'\s*#\s*undef\s*(\S*)' ) # all #undefs

ifdefCommonRe = re.compile( r'\s*#\s*if' ) # all #ifdefs
ifdefRe = re.compile( r'\s*#\s*ifdef\s*(\S*)' )
ifndefRe = re.compile( r'\s*#\s*ifndef\s*(\S*)' )
endifRe = re.compile( r'\s*#\s*endif(.*)' )
elseRe = re.compile( r'\s*#\s*else' )
ifRe = re.compile( r'\s*#\s*if\s+(.*)' )

rootPath = os.path.dirname(os.path.realpath( os.path.dirname(sys.argv[0])))
srcsPath = os.path.join( rootPath, 'src' )
includePath = os.path.join( rootPath, 'include' )
singleIncludePath = os.path.join( rootPath, 'single_include' )
extIncludePath = os.path.join( includePath, "external" )
thirdPartyPath = os.path.join( rootPath, 'third_party' )
firstHeaderPath = os.path.join( includePath, 'clara.hpp' )
outPath = os.path.join( singleIncludePath, 'clara.hpp' )

o = open( outPath, 'w' )

systemHeaders = set([])
projectHeaders = set([])
defines = set([])
LevelMax = 9999
suppressUntilLevel = LevelMax
level = 0

class FileParser:
    filename = ""

    def __init__( self, filename ):
        self.filename = filename

    def findHeader( self, headerFile ):

        # !TBD: make this array based

        # First check next to current file
        dir, _ = os.path.split( self.filename )
        fullPath = os.path.join( dir, headerFile )
        if os.path.isfile(fullPath):
            return fullPath

        # Next check include folder
        fullPath = os.path.join( includePath, headerFile )
        if os.path.isfile(fullPath):
            return fullPath

        # Then ext folder
        fullPath = os.path.join( extIncludePath, headerFile )
        if os.path.isfile(fullPath):
            return fullPath

        # Finally check ThirdParty folder
        fullPath = os.path.join( thirdPartyPath, headerFile )
        if os.path.isfile(fullPath):
            return fullPath

        raise FileNotFoundError( "Cannot locate include file: '" + filename + "'" )


    def parse( self ):
        with open( self.filename, 'r' ) as f:
            for line in f:
                if preprocessorRe.match( line ):
                    self.handlePreprocessor( line )
                else:
                    self.handleNonPP( line )

    def handleNonPP( self, line ):
        if suppressUntilLevel > level:
            self.writeLine( line )

    def handlePreprocessor( self, line ):
        if includesRe.match( line ):
            if suppressUntilLevel > level:
                self.handleInclude( line )
        else:
            self.handleNonIncludePP( line )

    def handleInclude( self, line ):
        global systemHeaders
        global projectHeaders
        m = sysIncludesRe.match( line )
        if m:
            headerFile = m.group(1)
            if not headerFile in systemHeaders:
                self.writeLine( "#include <{0}>".format( headerFile ) )
                systemHeaders.add( headerFile )

        m = prjIncludesRe.match( line )
        if m:
            headerFile = m.group(1)
            if not headerFile in projectHeaders:            
                self.writeLine( '\n// ----------- #included from {0} -----------'.format( headerFile ) )
                self.writeLine( "" )
                projectHeaders.add( headerFile )

                _, filename = os.path.split( self.filename )
                headerPath = self.findHeader( headerFile )
                p = FileParser( headerPath )
                p.parse()
                self.writeLine( '\n// ----------- end of #include from {0} -----------'.format( headerFile ) )
                self.writeLine( '// ........... back in {0}'.format( filename ) )
                self.writeLine( "" )

    def handleNonIncludePP( self, line ):
        m = endifRe.match( line )
        if m:
            self.handleEndif( m.group(1) )
        m = elseRe.match( line )
        if m:
            self.handleElse()

        if ifdefCommonRe.match( line ):
            self.handleIfdefCommon( line )

        if suppressUntilLevel > level:
            m = defineRe.match( line )
            if m:
                if fdefineRe.match( line ):
                    self.writeLine( line )
                else:
                    self.handleDefine( m.group(1), m.group(2) )
            m = undefRe.match( line )
            if m:
                self.handleUndef( m.group(1) )
        
    def handleDefine( self, define, value ):
        self.writeLine( "#define {0} {1}".format( define, value ) )
        defines.add( define )

    def handleUndef( self, define ):
        self.writeLine( "#undef {0}".format( define ) )
        defines.remove( define )

    def handleIfdefCommon( self, line ):
        global level
        level = level + 1
        m = ifndefRe.match( line )
        if m:
            self.handleIfndef( m.group(1) )
        else:
            m = ifdefRe.match( line )
            if m:
                self.handleIfdef( m.group(1) )
            else:
                m = ifRe.match( line )
                if m:
                    self.handleIf( m.group(1) )
                else:
                    print "****** error ***** " + line

    def handleEndif( self, trailing ):
        global level
        global suppressUntilLevel
        self.writeLine( "#endif{0}".format( trailing ) )
        level = level - 1
        if level == suppressUntilLevel:
            suppressUntilLevel = LevelMax

    def handleElse( self ):
        global suppressUntilLevel
        self.writeLine( "#else" )
        if level == suppressUntilLevel+1:
            suppressUntilLevel = LevelMax

    def handleIfndef( self, define ):
        self.writeLine( "#ifndef {0}".format( define ) )
        if define not in defines:
            suppressUntilLevel = level
    
    def handleIfdef( self, define ):
        self.writeLine( "#ifdef {0}".format( define ) )
        if define in defines:
            suppressUntilLevel = level

    def handleIf( self, trailing ):
        global level
        global suppressUntilLevel
        self.writeLine( "#if {0}".format( trailing ) )
        level = level + 1
#        if level == suppressUntilLevel:
#            suppressUntilLevel = LevelMax


    def writeLine( self, line ):
        o.write( line.rstrip() + "\n" )

print( "from: " + firstHeaderPath )
print( "to: " + outPath )
p = FileParser( firstHeaderPath )
p.parse()

o.close()

print "-------------"
print level
#for h in systemHeaders:
#    print "#include <" + h + ">"
#print
#
#for h in projectHeaders:
#    print '#include "' + h + '"'
#print
#for d in defines:
#    print d
#print


================================================
FILE: single_include/clara.hpp
================================================
// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See https://github.com/philsquared/Clara for more details

// Clara v1.1.5

#ifndef CLARA_HPP_INCLUDED
#define CLARA_HPP_INCLUDED

#ifndef CLARA_CONFIG_CONSOLE_WIDTH
#define CLARA_CONFIG_CONSOLE_WIDTH 80
#endif

#ifndef CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
#define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
#endif

#ifndef CLARA_CONFIG_OPTIONAL_TYPE
#ifdef __has_include
#if __has_include(<optional>) && __cplusplus >= 201703L
#include <optional>
#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
#endif
#endif
#endif


// ----------- #included from clara_textflow.hpp -----------

// TextFlowCpp
//
// A single-header library for wrapping and laying out basic text, by Phil Nash
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// This project is hosted at https://github.com/philsquared/textflowcpp

#ifndef CLARA_TEXTFLOW_HPP_INCLUDED
#define CLARA_TEXTFLOW_HPP_INCLUDED

#include <cassert>
#include <ostream>
#include <sstream>
#include <vector>

#ifndef CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
#define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
#endif


namespace clara { namespace TextFlow {

    inline auto isWhitespace( char c ) -> bool {
        static std::string chars = " \t\n\r";
        return chars.find( c ) != std::string::npos;
    }
    inline auto isBreakableBefore( char c ) -> bool {
        static std::string chars = "[({<|";
        return chars.find( c ) != std::string::npos;
    }
    inline auto isBreakableAfter( char c ) -> bool {
        static std::string chars = "])}>.,:;*+-=&/\\";
        return chars.find( c ) != std::string::npos;
    }

    class Columns;

    class Column {
        std::vector<std::string> m_strings;
        size_t m_width = CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
        size_t m_indent = 0;
        size_t m_initialIndent = std::string::npos;

    public:
        class iterator {
            friend Column;

            Column const& m_column;
            size_t m_stringIndex = 0;
            size_t m_pos = 0;

            size_t m_len = 0;
            size_t m_end = 0;
            bool m_suffix = false;

            iterator( Column const& column, size_t stringIndex )
            :   m_column( column ),
                m_stringIndex( stringIndex )
            {}

            auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }

            auto isBoundary( size_t at ) const -> bool {
                assert( at > 0 );
                assert( at <= line().size() );

                return at == line().size() ||
                       ( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
                       isBreakableBefore( line()[at] ) ||
                       isBreakableAfter( line()[at-1] );
            }

            void calcLength() {
                assert( m_stringIndex < m_column.m_strings.size() );

                m_suffix = false;
                auto width = m_column.m_width-indent();
                m_end = m_pos;
                while( m_end < line().size() && line()[m_end] != '\n' )
                    ++m_end;

                if( m_end < m_pos + width ) {
                    m_len = m_end - m_pos;
                }
                else {
                    size_t len = width;
                    while (len > 0 && !isBoundary(m_pos + len))
                        --len;
                    while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
                        --len;

                    if (len > 0) {
                        m_len = len;
                    } else {
                        m_suffix = true;
                        m_len = width - 1;
                    }
                }
            }

            auto indent() const -> size_t {
                auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
                return initial == std::string::npos ? m_column.m_indent : initial;
            }

            auto addIndentAndSuffix(std::string const &plain) const -> std::string {
                return std::string( indent(), ' ' ) + (m_suffix ? plain + "-" : plain);
            }

        public:
            using difference_type = std::ptrdiff_t;
            using value_type = std::string;
            using pointer = value_type*;
            using reference = value_type&;
            using iterator_category = std::forward_iterator_tag;

            explicit iterator( Column const& column ) : m_column( column ) {
                assert( m_column.m_width > m_column.m_indent );
                assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
                calcLength();
                if( m_len == 0 )
                    m_stringIndex++; // Empty string
            }

            auto operator *() const -> std::string {
                assert( m_stringIndex < m_column.m_strings.size() );
                assert( m_pos <= m_end );
                return addIndentAndSuffix(line().substr(m_pos, m_len));
            }

            auto operator ++() -> iterator& {
                m_pos += m_len;
                if( m_pos < line().size() && line()[m_pos] == '\n' )
                    m_pos += 1;
                else
                    while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
                        ++m_pos;

                if( m_pos == line().size() ) {
                    m_pos = 0;
                    ++m_stringIndex;
                }
                if( m_stringIndex < m_column.m_strings.size() )
                    calcLength();
                return *this;
            }
            auto operator ++(int) -> iterator {
                iterator prev( *this );
                operator++();
                return prev;
            }

            auto operator ==( iterator const& other ) const -> bool {
                return
                    m_pos == other.m_pos &&
                    m_stringIndex == other.m_stringIndex &&
                    &m_column == &other.m_column;
            }
            auto operator !=( iterator const& other ) const -> bool {
                return !operator==( other );
            }
        };
        using const_iterator = iterator;

        explicit Column( std::string const& text ) { m_strings.push_back( text ); }

        auto width( size_t newWidth ) -> Column& {
            assert( newWidth > 0 );
            m_width = newWidth;
            return *this;
        }
        auto indent( size_t newIndent ) -> Column& {
            m_indent = newIndent;
            return *this;
        }
        auto initialIndent( size_t newIndent ) -> Column& {
            m_initialIndent = newIndent;
            return *this;
        }

        auto width() const -> size_t { return m_width; }
        auto begin() const -> iterator { return iterator( *this ); }
        auto end() const -> iterator { return { *this, m_strings.size() }; }

        inline friend std::ostream& operator << ( std::ostream& os, Column const& col ) {
            bool first = true;
            for( auto line : col ) {
                if( first )
                    first = false;
                else
                    os << "\n";
                os <<  line;
            }
            return os;
        }

        auto operator + ( Column const& other ) -> Columns;

        auto toString() const -> std::string {
            std::ostringstream oss;
            oss << *this;
            return oss.str();
        }
    };

    class Spacer : public Column {

    public:
        explicit Spacer( size_t spaceWidth ) : Column( "" ) {
            width( spaceWidth );
        }
    };

    class Columns {
        std::vector<Column> m_columns;

    public:

        class iterator {
            friend Columns;
            struct EndTag {};

            std::vector<Column> const& m_columns;
            std::vector<Column::iterator> m_iterators;
            size_t m_activeIterators;

            iterator( Columns const& columns, EndTag )
            :   m_columns( columns.m_columns ),
                m_activeIterators( 0 )
            {
                m_iterators.reserve( m_columns.size() );

                for( auto const& col : m_columns )
                    m_iterators.push_back( col.end() );
            }

        public:
            using difference_type = std::ptrdiff_t;
            using value_type = std::string;
            using pointer = value_type*;
            using reference = value_type&;
            using iterator_category = std::forward_iterator_tag;

            explicit iterator( Columns const& columns )
            :   m_columns( columns.m_columns ),
                m_activeIterators( m_columns.size() )
            {
                m_iterators.reserve( m_columns.size() );

                for( auto const& col : m_columns )
                    m_iterators.push_back( col.begin() );
            }

            auto operator ==( iterator const& other ) const -> bool {
                return m_iterators == other.m_iterators;
            }
            auto operator !=( iterator const& other ) const -> bool {
                return m_iterators != other.m_iterators;
            }
            auto operator *() const -> std::string {
                std::string row, padding;

                for( size_t i = 0; i < m_columns.size(); ++i ) {
                    auto width = m_columns[i].width();
                    if( m_iterators[i] != m_columns[i].end() ) {
                        std::string col = *m_iterators[i];
                        row += padding + col;
                        if( col.size() < width )
                            padding = std::string( width - col.size(), ' ' );
                        else
                            padding = "";
                    }
                    else {
                        padding += std::string( width, ' ' );
                    }
                }
                return row;
            }
            auto operator ++() -> iterator& {
                for( size_t i = 0; i < m_columns.size(); ++i ) {
                    if (m_iterators[i] != m_columns[i].end())
                        ++m_iterators[i];
                }
                return *this;
            }
            auto operator ++(int) -> iterator {
                iterator prev( *this );
                operator++();
                return prev;
            }
        };
        using const_iterator = iterator;

        auto begin() const -> iterator { return iterator( *this ); }
        auto end() const -> iterator { return { *this, iterator::EndTag() }; }

        auto operator += ( Column const& col ) -> Columns& {
            m_columns.push_back( col );
            return *this;
        }
        auto operator + ( Column const& col ) -> Columns {
            Columns combined = *this;
            combined += col;
            return combined;
        }

        inline friend std::ostream& operator << ( std::ostream& os, Columns const& cols ) {

            bool first = true;
            for( auto line : cols ) {
                if( first )
                    first = false;
                else
                    os << "\n";
                os << line;
            }
            return os;
        }

        auto toString() const -> std::string {
            std::ostringstream oss;
            oss << *this;
            return oss.str();
        }
    };

    inline auto Column::operator + ( Column const& other ) -> Columns {
        Columns cols;
        cols += *this;
        cols += other;
        return cols;
    }
}}

#endif // CLARA_TEXTFLOW_HPP_INCLUDED

// ----------- end of #include from clara_textflow.hpp -----------
// ........... back in clara.hpp


#include <memory>
#include <set>
#include <algorithm>

#if !defined(CLARA_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
#define CLARA_PLATFORM_WINDOWS
#endif

namespace clara {
namespace detail {

    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
    template<typename L>
    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};

    template<typename ClassT, typename ReturnT, typename... Args>
    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
        static const bool isValid = false;
    };

    template<typename ClassT, typename ReturnT, typename ArgT>
    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
        static const bool isValid = true;
        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
        using ReturnType = ReturnT;
    };

    class TokenStream;

    // Transport for raw args (copied from main args, or supplied via init list for testing)
    class Args {
        friend TokenStream;
        std::string m_exeName;
        std::vector<std::string> m_args;

    public:
        Args( int argc, char const* const* argv )
            : m_exeName(argv[0]),
              m_args(argv + 1, argv + argc) {}

        Args( std::initializer_list<std::string> args )
        :   m_exeName( *args.begin() ),
            m_args( args.begin()+1, args.end() )
        {}

        auto exeName() const -> std::string {
            return m_exeName;
        }
    };

    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
    // may encode an option + its argument if the : or = form is used
    enum class TokenType {
        Option, Argument
    };
    struct Token {
        TokenType type;
        std::string token;
    };

    inline auto isOptPrefix( char c ) -> bool {
        return c == '-'
#ifdef CLARA_PLATFORM_WINDOWS
            || c == '/'
#endif
        ;
    }

    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
    class TokenStream {
        using Iterator = std::vector<std::string>::const_iterator;
        Iterator it;
        Iterator itEnd;
        std::vector<Token> m_tokenBuffer;

        void loadBuffer() {
            m_tokenBuffer.resize( 0 );

            // Skip any empty strings
            while( it != itEnd && it->empty() )
                ++it;

            if( it != itEnd ) {
                auto const &next = *it;
                if( isOptPrefix( next[0] ) ) {
                    auto delimiterPos = next.find_first_of( " :=" );
                    if( delimiterPos != std::string::npos ) {
                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
                    } else {
                        if( next[1] != '-' && next.size() > 2 ) {
                            std::string opt = "- ";
                            for( size_t i = 1; i < next.size(); ++i ) {
                                opt[1] = next[i];
                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
                            }
                        } else {
                            m_tokenBuffer.push_back( { TokenType::Option, next } );
                        }
                    }
                } else {
                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
                }
            }
        }

    public:
        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}

        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
            loadBuffer();
        }

        explicit operator bool() const {
            return !m_tokenBuffer.empty() || it != itEnd;
        }

        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }

        auto operator*() const -> Token {
            assert( !m_tokenBuffer.empty() );
            return m_tokenBuffer.front();
        }

        auto operator->() const -> Token const * {
            assert( !m_tokenBuffer.empty() );
            return &m_tokenBuffer.front();
        }

        auto operator++() -> TokenStream & {
            if( m_tokenBuffer.size() >= 2 ) {
                m_tokenBuffer.erase( m_tokenBuffer.begin() );
            } else {
                if( it != itEnd )
                    ++it;
                loadBuffer();
            }
            return *this;
        }
    };


    class ResultBase {
    public:
        enum Type {
            Ok, LogicError, RuntimeError
        };

    protected:
        ResultBase( Type type ) : m_type( type ) {}
        virtual ~ResultBase() = default;

        virtual void enforceOk() const = 0;

        Type m_type;
    };

    template<typename T>
    class ResultValueBase : public ResultBase {
    public:
        auto value() const -> T const & {
            enforceOk();
            return m_value;
        }

    protected:
        ResultValueBase( Type type ) : ResultBase( type ) {}

        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
            if( m_type == ResultBase::Ok )
                new( &m_value ) T( other.m_value );
        }

        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
            new( &m_value ) T( value );
        }

        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
            if( m_type == ResultBase::Ok )
                m_value.~T();
            ResultBase::operator=(other);
            if( m_type == ResultBase::Ok )
                new( &m_value ) T( other.m_value );
            return *this;
        }

        ~ResultValueBase() override {
            if( m_type == Ok )
                m_value.~T();
        }

        union {
            T m_value;
        };
    };

    template<>
    class ResultValueBase<void> : public ResultBase {
    protected:
        using ResultBase::ResultBase;
    };

    template<typename T = void>
    class BasicResult : public ResultValueBase<T> {
    public:
        template<typename U>
        explicit BasicResult( BasicResult<U> const &other )
        :   ResultValueBase<T>( other.type() ),
            m_errorMessage( other.errorMessage() )
        {
            assert( type() != ResultBase::Ok );
        }

        template<typename U>
        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }

        explicit operator bool() const { return m_type == ResultBase::Ok; }
        auto type() const -> ResultBase::Type { return m_type; }
        auto errorMessage() const -> std::string { return m_errorMessage; }

    protected:
        void enforceOk() const override {

            // Errors shouldn't reach this point, but if they do
            // the actual error message will be in m_errorMessage
            assert( m_type != ResultBase::LogicError );
            assert( m_type != ResultBase::RuntimeError );
            if( m_type != ResultBase::Ok )
                std::abort();
        }

        std::string m_errorMessage; // Only populated if resultType is an error

        BasicResult( ResultBase::Type type, std::string const &message )
        :   ResultValueBase<T>(type),
            m_errorMessage(message)
        {
            assert( m_type != ResultBase::Ok );
        }

        using ResultValueBase<T>::ResultValueBase;
        using ResultBase::m_type;
    };

    enum class ParseResultType {
        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
    };

    class ParseState {
    public:

        ParseState( ParseResultType type, TokenStream const &remainingTokens )
        : m_type(type),
          m_remainingTokens( remainingTokens )
        {}

        auto type() const -> ParseResultType { return m_type; }
        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }

    private:
        ParseResultType m_type;
        TokenStream m_remainingTokens;
    };

    using Result = BasicResult<void>;
    using ParserResult = BasicResult<ParseResultType>;
    using InternalParseResult = BasicResult<ParseState>;

    struct HelpColumns {
        std::string left;
        std::string right;
    };

    template<typename T>
    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
        std::stringstream ss;
        ss << source;
        ss >> target;
        if( ss.fail() )
            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
        else
            return ParserResult::ok( ParseResultType::Matched );
    }
    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
        target = source;
        return ParserResult::ok( ParseResultType::Matched );
    }
    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
        std::string srcLC = source;
        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
            target = true;
        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
            target = false;
        else
            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
        return ParserResult::ok( ParseResultType::Matched );
    }
#ifdef CLARA_CONFIG_OPTIONAL_TYPE
    template<typename T>
    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
        T temp;
        auto result = convertInto( source, temp );
        if( result )
            target = std::move(temp);
        return result;
    }
#endif // CLARA_CONFIG_OPTIONAL_TYPE

    struct NonCopyable {
        NonCopyable() = default;
        NonCopyable( NonCopyable const & ) = delete;
        NonCopyable( NonCopyable && ) = delete;
        NonCopyable &operator=( NonCopyable const & ) = delete;
        NonCopyable &operator=( NonCopyable && ) = delete;
    };

    struct BoundRef : NonCopyable {
        virtual ~BoundRef() = default;
        virtual auto isContainer() const -> bool { return false; }
        virtual auto isFlag() const -> bool { return false; }
    };
    struct BoundValueRefBase : BoundRef {
        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
    };
    struct BoundFlagRefBase : BoundRef {
        virtual auto setFlag( bool flag ) -> ParserResult = 0;
        virtual auto isFlag() const -> bool { return true; }
    };

    template<typename T>
    struct BoundValueRef : BoundValueRefBase {
        T &m_ref;

        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}

        auto setValue( std::string const &arg ) -> ParserResult override {
            return convertInto( arg, m_ref );
        }
    };

    template<typename T>
    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
        std::vector<T> &m_ref;

        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}

        auto isContainer() const -> bool override { return true; }

        auto setValue( std::string const &arg ) -> ParserResult override {
            T temp;
            auto result = convertInto( arg, temp );
            if( result )
                m_ref.push_back( temp );
            return result;
        }
    };

    struct BoundFlagRef : BoundFlagRefBase {
        bool &m_ref;

        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}

        auto setFlag( bool flag ) -> ParserResult override {
            m_ref = flag;
            return ParserResult::ok( ParseResultType::Matched );
        }
    };

    template<typename ReturnType>
    struct LambdaInvoker {
        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );

        template<typename L, typename ArgType>
        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
            return lambda( arg );
        }
    };

    template<>
    struct LambdaInvoker<void> {
        template<typename L, typename ArgType>
        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
            lambda( arg );
            return ParserResult::ok( ParseResultType::Matched );
        }
    };

    template<typename ArgType, typename L>
    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
        ArgType temp{};
        auto result = convertInto( arg, temp );
        return !result
           ? result
           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
    }


    template<typename L>
    struct BoundLambda : BoundValueRefBase {
        L m_lambda;

        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}

        auto setValue( std::string const &arg ) -> ParserResult override {
            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
        }
    };

    template<typename L>
    struct BoundFlagLambda : BoundFlagRefBase {
        L m_lambda;

        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );

        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}

        auto setFlag( bool flag ) -> ParserResult override {
            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
        }
    };

    enum class Optionality { Optional, Required };

    struct Parser;

    class ParserBase {
    public:
        virtual ~ParserBase() = default;
        virtual auto validate() const -> Result { return Result::ok(); }
        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
        virtual auto cardinality() const -> size_t { return 1; }

        auto parse( Args const &args ) const -> InternalParseResult {
            return parse( args.exeName(), TokenStream( args ) );
        }
    };

    template<typename DerivedT>
    class ComposableParserImpl : public ParserBase {
    public:
        template<typename T>
        auto operator|( T const &other ) const -> Parser;

		template<typename T>
        auto operator+( T const &other ) const -> Parser;
    };

    // Common code and state for Args and Opts
    template<typename DerivedT>
    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
    protected:
        Optionality m_optionality = Optionality::Optional;
        std::shared_ptr<BoundRef> m_ref;
        std::string m_hint;
        std::string m_description;

        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}

    public:
        template<typename T>
        ParserRefImpl( T &ref, std::string const &hint )
        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
            m_hint( hint )
        {}

        template<typename LambdaT>
        ParserRefImpl( LambdaT const &ref, std::string const &hint )
        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
            m_hint(hint)
        {}

        auto operator()( std::string const &description ) -> DerivedT & {
            m_description = description;
            return static_cast<DerivedT &>( *this );
        }

        auto optional() -> DerivedT & {
            m_optionality = Optionality::Optional;
            return static_cast<DerivedT &>( *this );
        };

        auto required() -> DerivedT & {
            m_optionality = Optionality::Required;
            return static_cast<DerivedT &>( *this );
        };

        auto isOptional() const -> bool {
            return m_optionality == Optionality::Optional;
        }

        auto cardinality() const -> size_t override {
            if( m_ref->isContainer() )
                return 0;
            else
                return 1;
        }

        auto hint() const -> std::string { return m_hint; }
    };

    class ExeName : public ComposableParserImpl<ExeName> {
        std::shared_ptr<std::string> m_name;
        std::shared_ptr<BoundValueRefBase> m_ref;

        template<typename LambdaT>
        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
        }

    public:
        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}

        explicit ExeName( std::string &ref ) : ExeName() {
            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
        }

        template<typename LambdaT>
        explicit ExeName( LambdaT const& lambda ) : ExeName() {
            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
        }

        // The exe name is not parsed out of the normal tokens, but is handled specially
        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
        }

        auto name() const -> std::string { return *m_name; }
        auto set( std::string const& newName ) -> ParserResult {

            auto lastSlash = newName.find_last_of( "\\/" );
            auto filename = ( lastSlash == std::string::npos )
                    ? newName
                    : newName.substr( lastSlash+1 );

            *m_name = filename;
            if( m_ref )
                return m_ref->setValue( filename );
            else
                return ParserResult::ok( ParseResultType::Matched );
        }
    };

    class Arg : public ParserRefImpl<Arg> {
    public:
        using ParserRefImpl::ParserRefImpl;

        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
            auto validationResult = validate();
            if( !validationResult )
                return InternalParseResult( validationResult );

            auto remainingTokens = tokens;
            auto const &token = *remainingTokens;
            if( token.type != TokenType::Argument )
                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );

            assert( !m_ref->isFlag() );
            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );

            auto result = valueRef->setValue( remainingTokens->token );
            if( !result )
                return InternalParseResult( result );
            else
                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
        }
    };

    inline auto normaliseOpt( std::string const &optName ) -> std::string {
#ifdef CLARA_PLATFORM_WINDOWS
        if( optName[0] == '/' )
            return "-" + optName.substr( 1 );
        else
#endif
            return optName;
    }

    class Opt : public ParserRefImpl<Opt> {
    protected:
        std::vector<std::string> m_optNames;

    public:
        template<typename LambdaT>
        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}

        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}

        template<typename LambdaT>
        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}

        template<typename T>
        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}

        auto operator[]( std::string const &optName ) -> Opt & {
            m_optNames.push_back( optName );
            return *this;
        }

        auto getHelpColumns() const -> std::vector<HelpColumns> {
            std::ostringstream oss;
            bool first = true;
            for( auto const &opt : m_optNames ) {
                if (first)
                    first = false;
                else
                    oss << ", ";
                oss << opt;
            }
            if( !m_hint.empty() )
                oss << " <" << m_hint << ">";
            return { { oss.str(), m_description } };
        }

        auto isMatch( std::string const &optToken ) const -> bool {
            auto normalisedToken = normaliseOpt( optToken );
            for( auto const &name : m_optNames ) {
                if( normaliseOpt( name ) == normalisedToken )
                    return true;
            }
            return false;
        }

        using ParserBase::parse;

        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
            auto validationResult = validate();
            if( !validationResult )
                return InternalParseResult( validationResult );

            auto remainingTokens = tokens;
            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
                auto const &token = *remainingTokens;
                if( isMatch(token.token ) ) {
                    if( m_ref->isFlag() ) {
                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
                        auto result = flagRef->setFlag( true );
                        if( !result )
                            return InternalParseResult( result );
                        if( result.value() == ParseResultType::ShortCircuitAll )
                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
                    } else {
                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
                        ++remainingTokens;
                        if( !remainingTokens )
                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
                        auto const &argToken = *remainingTokens;
                        if( argToken.type != TokenType::Argument )
                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
                        auto result = valueRef->setValue( argToken.token );
                        if( !result )
                            return InternalParseResult( result );
                        if( result.value() == ParseResultType::ShortCircuitAll )
                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
                    }
                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
                }
            }
            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
        }

        auto validate() const -> Result override {
            if( m_optNames.empty() )
                return Result::logicError( "No options supplied to Opt" );
            for( auto const &name : m_optNames ) {
                if( name.empty() )
                    return Result::logicError( "Option name cannot be empty" );
#ifdef CLARA_PLATFORM_WINDOWS
                if( name[0] != '-' && name[0] != '/' )
                    return Result::logicError( "Option name must begin with '-' or '/'" );
#else
                if( name[0] != '-' )
                    return Result::logicError( "Option name must begin with '-'" );
#endif
            }
            return ParserRefImpl::validate();
        }
    };

    struct Help : Opt {
        Help( bool &showHelpFlag )
        :   Opt([&]( bool flag ) {
                showHelpFlag = flag;
                return ParserResult::ok( ParseResultType::ShortCircuitAll );
            })
        {
            static_cast<Opt &>( *this )
                    ("display usage information")
                    ["-?"]["-h"]["--help"]
                    .optional();
        }
    };


    struct Parser : ParserBase {

        mutable ExeName m_exeName;
        std::vector<Opt> m_options;
        std::vector<Arg> m_args;

        auto operator|=( ExeName const &exeName ) -> Parser & {
            m_exeName = exeName;
            return *this;
        }

        auto operator|=( Arg const &arg ) -> Parser & {
            m_args.push_back(arg);
            return *this;
        }

        auto operator|=( Opt const &opt ) -> Parser & {
            m_options.push_back(opt);
            return *this;
        }

        auto operator|=( Parser const &other ) -> Parser & {
            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
            return *this;
        }

        template<typename T>
        auto operator|( T const &other ) const -> Parser {
            return Parser( *this ) |= other;
        }

        // Forward deprecated interface with '+' instead of '|'
        template<typename T>
        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
        template<typename T>
        auto operator+( T const &other ) const -> Parser { return operator|( other ); }

        auto getHelpColumns() const -> std::vector<HelpColumns> {
            std::vector<HelpColumns> cols;
            for (auto const &o : m_options) {
                auto childCols = o.getHelpColumns();
                cols.insert( cols.end(), childCols.begin(), childCols.end() );
            }
            return cols;
        }

        void writeToStream( std::ostream &os ) const {
            if (!m_exeName.name().empty()) {
                os << "usage:\n" << "  " << m_exeName.name() << " ";
                bool required = true, first = true;
                for( auto const &arg : m_args ) {
                    if (first)
                        first = false;
                    else
                        os << " ";
                    if( arg.isOptional() && required ) {
                        os << "[";
                        required = false;
                    }
                    os << "<" << arg.hint() << ">";
                    if( arg.cardinality() == 0 )
                        os << " ... ";
                }
                if( !required )
                    os << "]";
                if( !m_options.empty() )
                    os << " options";
                os << "\n\nwhere options are:" << std::endl;
            }

            auto rows = getHelpColumns();
            size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
            size_t optWidth = 0;
            for( auto const &cols : rows )
                optWidth = (std::max)(optWidth, cols.left.size() + 2);

            optWidth = (std::min)(optWidth, consoleWidth/2);

            for( auto const &cols : rows ) {
                auto row =
                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
                        TextFlow::Spacer(4) +
                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
                os << row << std::endl;
            }
        }

        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
            parser.writeToStream( os );
            return os;
        }

        auto validate() const -> Result override {
            for( auto const &opt : m_options ) {
                auto result = opt.validate();
                if( !result )
                    return result;
            }
            for( auto const &arg : m_args ) {
                auto result = arg.validate();
                if( !result )
                    return result;
            }
            return Result::ok();
        }

        using ParserBase::parse;

        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {

            struct ParserInfo {
                ParserBase const* parser = nullptr;
                size_t count = 0;
            };
            const size_t totalParsers = m_options.size() + m_args.size();
            assert( totalParsers < 512 );
            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
            ParserInfo parseInfos[512];

            {
                size_t i = 0;
                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
            }

            m_exeName.set( exeName );

            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
            while( result.value().remainingTokens() ) {
                bool tokenParsed = false;

                for( size_t i = 0; i < totalParsers; ++i ) {
                    auto&  parseInfo = parseInfos[i];
                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
                        if (!result)
                            return result;
                        if (result.value().type() != ParseResultType::NoMatch) {
                            tokenParsed = true;
                            ++parseInfo.count;
                            break;
                        }
                    }
                }

                if( result.value().type() == ParseResultType::ShortCircuitAll )
                    return result;
                if( !tokenParsed )
                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
            }
            // !TBD Check missing required options
            return result;
        }
    };

    template<typename DerivedT>
    template<typename T>
    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
        return Parser() | static_cast<DerivedT const &>( *this ) | other;
    }
} // namespace detail


// A Combined parser
using detail::Parser;

// A parser for options
using detail::Opt;

// A parser for arguments
using detail::Arg;

// Wrapper for argc, argv from main()
using detail::Args;

// Specifies the name of the executable
using detail::ExeName;

// Convenience wrapper for option parser that specifies the help option
using detail::Help;

// enum of result types from a parse
using detail::ParseResultType;

// Result type for parser operation
using detail::ParserResult;


} // namespace clara

#endif // CLARA_HPP_INCLUDED


================================================
FILE: src/ClaraTests.cpp
================================================
#include "clara.hpp"

#include "catch.hpp"

#include <iostream>

using namespace clara;

namespace Catch {
template<>
struct StringMaker<clara::detail::InternalParseResult> {
    static std::string convert( clara::detail::InternalParseResult const& result ) {
        switch( result.type() ) {
            case clara::detail::ResultBase::Ok:
                return "Ok";
            case clara::detail::ResultBase::LogicError:
                return "LogicError '" + result.errorMessage() + "'";
            case clara::detail::ResultBase::RuntimeError:
                return "RuntimeError: '" + result.errorMessage() + "'";
            default:
                return "Unknow type: " + std::to_string( static_cast<int>( result.type() ) );
        }
    }
};
}

std::string toString( Opt const& opt ) {
    std::ostringstream oss;
    oss << (Parser() | opt);
    return oss.str();
}
std::string toString( Parser const& p ) {
    std::ostringstream oss;
    oss << p;
    return oss.str();
}

// !TBD
// for Catch:
// error on unrecognised?

// Beyond Catch:
// exceptions or not
// error on unmet requireds
// enum mapping
// sets of values (in addition to vectors)
// arg literals
// --help for option names/ args/ arg literals
// other dependencies/ hierarchical parsers
// Exclusive() parser for choices

TEST_CASE( "single parsers" ) {

    std::string name;
    auto p = Opt(name, "name")
        ["-n"]["--name"]
        ("the name to use");

    REQUIRE( name == "" );

    SECTION( "-n" ) {
        p.parse( Args{ "TestApp", "-n", "Vader" } );
        REQUIRE( name == "Vader");
    }
    SECTION( "--name" ) {
        p.parse( Args{ "TestApp", "--name", "Vader" } );
        REQUIRE( name == "Vader");
    }
    SECTION( "-n:" ) {
        p.parse( Args{ "TestApp", "-n:Vader" } );
        REQUIRE( name == "Vader");
    }
    SECTION( "-n=" ) {
        p.parse( Args{ "TestApp", "-n=Vader" } );
        REQUIRE( name == "Vader");
    }
    SECTION( "no args" ) {
        p.parse( Args{ "TestApp" } );
        REQUIRE( name == "");
    }
    SECTION( "different args" ) {
        p.parse( Args{ "TestApp", "-f" } );
        REQUIRE( name == "");
    }
}

struct Config {
    int m_rngSeed;
    std::string m_name;
    std::vector<std::string> m_tests;
    bool m_flag = false;
    double m_value = 0;
};

TEST_CASE( "Combined parser" ) {
    Config config;

    bool showHelp = false;
    auto parser
            = Help( showHelp )
            | Opt( config.m_rngSeed, "time|value" )
                ["--rng-seed"]["-r"]
                ("set a specific seed for random numbers" )
                .required()
            | Opt( config.m_name, "name" )
                ["-n"]["--name"]
                ( "the name to use" )
            | Opt( config.m_flag )
                ["-f"]["--flag"]
                ( "a flag to set" )
            | Opt( [&]( double value ){ config.m_value = value; }, "number" )
                ["-d"]["--double"]
                ( "just some number" )
            | Arg( config.m_tests, "test name|tags|pattern" )
                ( "which test or tests to use" );

    SECTION( "usage" ) {
        REQUIRE(toString(parser) ==
                    "usage:\n"
                    "  <executable> [<test name|tags|pattern> ... ] options\n"
                    "\n"
                    "where options are:\n"
                    "  -?, -h, --help                 display usage information\n"
                    "  --rng-seed, -r <time|value>    set a specific seed for random numbers\n"
                    "  -n, --name <name>              the name to use\n"
                    "  -f, --flag                     a flag to set\n"
                    "  -d, --double <number>          just some number\n"
        );
    }
    SECTION( "some args" ) {
        auto result = parser.parse( Args{ "TestApp", "-n", "Bill", "-d:123.45", "-f", "test1", "test2" } );
        CHECK( result );
        CHECK( result.value().type() == ParseResultType::Matched );

        REQUIRE( config.m_name == "Bill" );
        REQUIRE( config.m_value == 123.45 );
        REQUIRE( config.m_tests == std::vector<std::string> { "test1", "test2" } );
        CHECK( showHelp == false );
    }
    SECTION( "help" ) {
        auto result = parser.parse( Args{ "TestApp", "-?", "-n:NotSet" } );
        CHECK( result );
        CHECK( result.value().type() == ParseResultType::ShortCircuitAll );
        CHECK( config.m_name == "" ); // We should never have processed -n:NotSet
        CHECK( showHelp == true );
    }
}

struct TestOpt {
    std::string processName;
    std::string fileName;
    int number = 0;
    int index = 0;
    bool flag = false;
    std::string firstPos;
    std::string secondPos;
    std::vector<std::string> unpositional;

    auto makeCli() -> Parser {
        return ExeName( processName )
          | Opt( fileName, "filename" )
              ["-o"]["--output"]
              ( "specifies output file" )
          | Opt( number, "an integral value" )
              ["-n"]
          | Opt( [&]( int i ) {
                    if (i < 0 || i > 10)
                        return ParserResult::runtimeError("index must be between 0 and 10");
                    else {
                        index = i;
                        return ParserResult::ok( ParseResultType::Matched );
                    }
                }, "index" )
              ["-i"]
              ( "An index, which is an integer between 0 and 10, inclusive" )
          | Opt( flag )
              ["-f"]
              ( "A flag" )
          | Arg( firstPos, "first arg" )
              ( "First position" )
          | Arg( secondPos, "second arg" )
              ( "Second position" );
    }
};

struct TestOpt2 {
    std::string description;
};

TEST_CASE( "cmdline" ) {

    TestOpt config;
    auto cli = config.makeCli();

    SECTION( "exe name" ) {
        auto result = cli.parse( { "TestApp", "-o", "filename.ext" } );
        CHECK( result );
        CHECK( config.processName == "TestApp" );
    }
    SECTION( "args" ) {
        auto result = cli.parse( { "TestApp", "-o", "filename.ext" } );
        CHECK( result );
        CHECK( config.fileName == "filename.ext" );
    }
    SECTION( "arg separated by colon" ) {
        auto result = cli.parse( { "TestApp", "-o:filename.ext" } );
        CHECK( result );
        CHECK( config.fileName == "filename.ext" );
    }
    SECTION( "arg separated by =" ) {
        auto result = cli.parse( { "TestApp", "-o=filename.ext" } );
        CHECK( result );
        CHECK( config.fileName == "filename.ext" );
    }
    SECTION( "long opt" ) {
        auto result = cli.parse( { "TestApp", "--output", "%stdout" } );
        CHECK( result );
        CHECK( config.fileName == "%stdout" );
    }
    SECTION( "a number" ) {
        auto result = cli.parse( { "TestApp", "-n", "42" } );
        CHECK( result );
        CHECK( config.number == 42 );
    }
    SECTION( "not a number" ) {
        auto result = cli.parse( { "TestApp", "-n", "forty-two" } );
        CHECK( !result );
        CHECK( result.errorMessage() == "Unable to convert 'forty-two' to destination type" );

        CHECK( config.number == 0 );
    }

    SECTION( "methods" ) {

        SECTION( "in range" ) {
            auto result = cli.parse( { "TestApp", "-i", "3" } );
            CHECK( result );

            REQUIRE( config.index == 3 );
        }
        SECTION( "out of range" ) {
            auto result = cli.parse( { "TestApp", "-i", "42" } );
            CHECK( !result );
            CHECK( result.errorMessage() == "index must be between 0 and 10" );
        }
    }

    SECTION( "flags" ) {

        SECTION("set") {
            auto result = cli.parse({ "TestApp", "-f" });
            CHECK( result );

            REQUIRE(config.flag);
        }
        SECTION("not set") {
            auto result = cli.parse({ "TestApp" });
            CHECK( result );
            CHECK( result.value().type() == ParseResultType::NoMatch);

            REQUIRE(config.flag == false);
        }

        SECTION( "arg before flag" )
        {
            auto result = cli.parse({ "TestApp", "-f", "something" });
            REQUIRE( result );
            REQUIRE( config.flag );
            REQUIRE( config.firstPos == "something" );
        }

        SECTION("following flag")
        {
            auto result = cli.parse({ "TestApp", "something", "-f" });
            REQUIRE( result );
            REQUIRE( config.flag );
            REQUIRE( config.firstPos == "something" );
        }

        SECTION("no flag")
        {
            auto result = cli.parse({ "TestApp", "something" });
            REQUIRE( result );
            REQUIRE( config.flag == false );
            REQUIRE( config.firstPos == "something" );
        }
    }

#ifdef CLARA_PLATFORM_WINDOWS
    SECTION( "forward slash" ) {
        auto result = cli.parse( { "TestApp", "/f" } );
        CHECK(result);

        REQUIRE( config.flag );
    }
#endif

    SECTION( "args" ) {

        auto result = cli.parse( { "TestApp", "-f", "1st", "-o", "filename", "2nd" } );
        CHECK( result );

        REQUIRE( config.firstPos == "1st" );
        REQUIRE( config.secondPos == "2nd" );
    }
}

TEST_CASE( "flag parser" ) {

    bool flag = false;
    auto p = Opt( flag, "true|false" )
            ["-f"]
            ("A flag");

    SECTION( "set flag with true" ) {
        auto result = p.parse( {"TestApp", "-f", "true"} );
        REQUIRE( result );
        REQUIRE( flag );
    }
    SECTION( "set flag with yes" ) {
        auto result = p.parse( {"TestApp", "-f", "yes"} );
        REQUIRE( result );
        REQUIRE( flag );
    }
    SECTION( "set flag with y" ) {
        auto result = p.parse( {"TestApp", "-f", "y"} );
        REQUIRE( result );
        REQUIRE( flag );
    }
    SECTION( "set flag with 1" ) {
        auto result = p.parse( {"TestApp", "-f", "1"} );
        REQUIRE( result );
        REQUIRE( flag );
    }
    SECTION( "set flag with on" ) {
        auto result = p.parse( {"TestApp", "-f", "on"} );
        REQUIRE( result );
        REQUIRE( flag );
    }
    SECTION( "set flag with tRUe" ) {
        auto result = p.parse( {"TestApp", "-f", "tRUe"} );
        REQUIRE( result );
        REQUIRE( flag );
    }

    SECTION( "unset flag with false" ) {
        flag = true;
        auto result = p.parse( {"TestApp", "-f", "false"} );
        REQUIRE( result) ;
        REQUIRE( flag == false );
    }
    SECTION( "invalid inputs" ) {
        using namespace Catch::Matchers;
        auto result = p.parse( {"TestApp", "-f", "what"} );
        REQUIRE( !result ) ;
        REQUIRE_THAT( result.errorMessage(), Contains( "Expected a boolean value" ) );

        result = p.parse( {"TestApp", "-f"} );
        REQUIRE( !result ) ;
        REQUIRE_THAT( result.errorMessage(), Contains( "Expected argument following -f" ) );
    }
}

TEST_CASE( "usage", "[.]" ) {

    TestOpt config;
    auto cli = config.makeCli();
    std::cout << cli << std::endl;
}

TEST_CASE( "Invalid parsers" )
{
    using namespace Catch::Matchers;

    TestOpt config;

    SECTION( "no options" )
    {
        auto cli = Opt( config.number, "number" );
        auto result = cli.parse( { "TestApp", "-o", "filename" } );
        CHECK( !result );
        CHECK( result.errorMessage() == "No options supplied to Opt" );
    }
    SECTION( "no option name" )
    {
        auto cli = Opt( config.number, "number" )[""];
        auto result = cli.parse( { "TestApp", "-o", "filename" } );
        CHECK( !result );
        CHECK( result.errorMessage() == "Option name cannot be empty" );
    }
    SECTION( "invalid option name" )
    {
        auto cli = Opt( config.number, "number" )["invalid"];
        auto result = cli.parse( { "TestApp", "-o", "filename" } );
        CHECK( !result );
        CHECK_THAT( result.errorMessage(), StartsWith( "Option name must begin with '-'" ) );
    }
}

TEST_CASE( "Multiple flags" ) {
    bool a = false, b = false, c = false;
    auto cli = Opt( a )["-a"] | Opt( b )["-b"] | Opt( c )["-c"];

    SECTION( "separately" ) {
        auto result = cli.parse({ "TestApp", "-a", "-b", "-c" });
        CHECK(result);
        CHECK(a);
        CHECK(b);
        CHECK(c);
    }
    SECTION( "combined" ) {
        auto result = cli.parse({ "TestApp", "-abc" });
        CHECK(result);
        CHECK(a);
        CHECK(b);
        CHECK(c);
    }
}

TEST_CASE( "Unrecognised opts" ) {
    using namespace Catch::Matchers;

    bool a = false;
    Parser cli = Parser() | Opt( a )["-a"];

    auto result = cli.parse( { "TestApp", "-b" } );
    CHECK( !result );
    CHECK_THAT( result.errorMessage(), Contains( "Unrecognised token") && Contains( "-b" ) );
}

TEST_CASE( "char* args" ) {

    std::string value;
    Parser cli = Parser() | Arg( value, "value" );

    SECTION( "char*" ) {
        char* args[] = { (char*)"TestApp", (char*)"hello" };

        auto result = cli.parse( Args( 2, args ) );
        REQUIRE( result );
        REQUIRE( value == "hello" );
    }
    SECTION( "char*" ) {
        const char* args[] = { "TestApp", "hello" };

        auto result = cli.parse( Args( 2, args ) );
        REQUIRE( result );
        REQUIRE( value == "hello" );
    }
}

TEST_CASE( "different widths" ) {

    std::string s;

    auto shortOpt
        = Opt( s, "short" )
           ["-s"]["--short"]
           ( "not much" );
    auto longHint
        = Opt( s, "A very very long hint that should force the whole line to wrap awkwardly. I hope no-one ever writes anything like thus - but there's always *someone*" )
           ["-x"]
           ("short description");

    auto longDesc
        = Opt( s, "hint")
            ["-y"]
            ( "In this one it's the description field that is really really long. We should be split over several lines, but complete the description before starting to show the next option" );

    auto longOptName
            = Opt( s, "hint")
            ["--this-one-just-has-an-overly-long-option-name-that-should-push-the-left-hand-column-out"]
            ( "short desc" );

    auto longEverything
        = Opt( s, "this is really over the top, but it has to be tested. In this case we have a very long hint (far longer than anyone should ever even think of using), which should be enough to wrap just on its own...")
            ["--and-a-ridiculously-long-long-option-name-that-would-be-silly-to-write-but-hey-if-it-can-handle-this-it-can-handle-anything-right"]
            ( "*and* a stupid long description, which seems a bit redundant give all the other verbosity. But some people just love to write. And read. You have to be prepared to do a lot of both for this to be useful.");

    SECTION( "long hint" )
        REQUIRE_NOTHROW( toString( longHint ) == "?" );

    SECTION( "long desc" )
        REQUIRE_NOTHROW( toString( longDesc ) );

    SECTION( "long opt name" )
        REQUIRE_NOTHROW( toString( longOptName ) == "?" );

    SECTION( "long everything" )
        REQUIRE_NOTHROW( toString( longEverything ) == "?" );
}

TEST_CASE( "newlines in description" ) {

    SECTION( "single, long description" ) {
        int i;
        auto opt = Opt(i, "i")["-i"](
                "This string should be long enough to force a wrap in the first instance. But what we really want to test is where if we put an explicit newline in the string, say, here\nthat it is formatted correctly");

        REQUIRE(toString(opt) ==
                "usage:\n"
                        "  <executable>  options\n"
                        "\n"
                        "where options are:\n"
                        "  -i <i>    This string should be long enough to force a wrap in the first\n"
                        "            instance. But what we really want to test is where if we put an\n"
                        "            explicit newline in the string, say, here\n"
                        "            that it is formatted correctly\n");
    }
    SECTION( "multiple entries" ) {
        int a,b,c;
        auto p
            = Opt(a, "a")
                ["-a"]["--longishOption"]
                ("A description with:\nA new line right in the middle")
            | Opt(b, "b")
                ["-b"]["--bb"]
                ("This description also has\nA new line")
              | Opt(c, "c")
                ["-c"]["--cc"]
                ("Another\nnewline. In fact this one has line-wraps, as well as mutiple\nnewlines and\n\n- leading hyphens");

        REQUIRE(toString(p) ==
                "usage:\n"
                        "  <executable>  options\n"
                        "\n"
                        "where options are:\n"
                        "  -a, --longishOption <a>    A description with:\n"
                        "                             A new line right in the middle\n"
                        "  -b, --bb <b>               This description also has\n"
                        "                             A new line\n"
                        "  -c, --cc <c>               Another\n"
                        "                             newline. In fact this one has line-wraps, as\n"
                        "                             well as mutiple\n"
                        "                             newlines and\n"
                        "                             \n"
                        "                             - leading hyphens\n");



    }
}

#if defined(CLARA_CONFIG_OPTIONAL_TYPE)
TEST_CASE("Reading into std::optional") {
    CLARA_CONFIG_OPTIONAL_TYPE<std::string> name;
    auto p = Opt(name, "name")
        ["-n"]["--name"]
        ("the name to use");
    SECTION("Not set") {
        auto result = p.parse(Args{ "TestApp", "-q", "Pixie" });
        REQUIRE( result );
        REQUIRE_FALSE( name.has_value() );
    }
    SECTION("Provided") {
        auto result = p.parse(Args{ "TestApp", "-n", "Pixie" });
        REQUIRE( result );
        REQUIRE( name.has_value() );
        REQUIRE( name.value() == "Pixie" );
    }
}
#endif // CLARA_CONFIG_OPTIONAL_TYPE


================================================
FILE: src/main.cpp
================================================
#define CATCH_CONFIG_MAIN
#include "catch.hpp"


================================================
FILE: third_party/TextFlow.hpp
================================================
// TextFlowCpp
//
// A single-header library for wrapping and laying out basic text, by Phil Nash
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// This project is hosted at https://github.com/philsquared/textflowcpp

#ifndef TEXTFLOW_HPP_INCLUDED
#define TEXTFLOW_HPP_INCLUDED

#include <cassert>
#include <ostream>
#include <sstream>
#include <vector>

#ifndef TEXTFLOW_CONFIG_CONSOLE_WIDTH
#define TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
#endif


namespace TextFlow {

    inline auto isWhitespace( char c ) -> bool {
        static std::string chars = " \t\n\r";
        return chars.find( c ) != std::string::npos;
    }
    inline auto isBreakableBefore( char c ) -> bool {
        static std::string chars = "[({<|";
        return chars.find( c ) != std::string::npos;
    }
    inline auto isBreakableAfter( char c ) -> bool {
        static std::string chars = "])}>.,:;*+-=&/\\";
        return chars.find( c ) != std::string::npos;
    }

    class Columns;

    class Column {
        std::vector<std::string> m_strings;
        size_t m_width = TEXTFLOW_CONFIG_CONSOLE_WIDTH;
        size_t m_indent = 0;
        size_t m_initialIndent = std::string::npos;

    public:
        class iterator {
            friend Column;

            Column const& m_column;
            size_t m_stringIndex = 0;
            size_t m_pos = 0;

            size_t m_len = 0;
            size_t m_end = 0;
            bool m_suffix = false;

            iterator( Column const& column, size_t stringIndex )
            :   m_column( column ),
                m_stringIndex( stringIndex )
            {}

            auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }

            auto isBoundary( size_t at ) const -> bool {
                assert( at > 0 );
                assert( at <= line().size() );

                return at == line().size() ||
                       ( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
                       isBreakableBefore( line()[at] ) ||
                       isBreakableAfter( line()[at-1] );
            }

            void calcLength() {
                assert( m_stringIndex < m_column.m_strings.size() );

                m_suffix = false;
                auto width = m_column.m_width-indent();
                m_end = m_pos;
                while( m_end < line().size() && line()[m_end] != '\n' )
                    ++m_end;

                if( m_end < m_pos + width ) {
                    m_len = m_end - m_pos;
                }
                else {
                    size_t len = width;
                    while (len > 0 && !isBoundary(m_pos + len))
                        --len;
                    while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
                        --len;

                    if (len > 0) {
                        m_len = len;
                    } else {
                        m_suffix = true;
                        m_len = width - 1;
                    }
                }
            }

            auto indent() const -> size_t {
                auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
                return initial == std::string::npos ? m_column.m_indent : initial;
            }

            auto addIndentAndSuffix(std::string const &plain) const -> std::string {
                return std::string( indent(), ' ' ) + (m_suffix ? plain + "-" : plain);
            }

        public:
            using difference_type = std::ptrdiff_t;
            using value_type = std::string;
            using pointer = value_type*;
            using reference = value_type&;
            using iterator_category = std::forward_iterator_tag;

            explicit iterator( Column const& column ) : m_column( column ) {
                assert( m_column.m_width > m_column.m_indent );
                assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
                calcLength();
                if( m_len == 0 )
                    m_stringIndex++; // Empty string
            }

            auto operator *() const -> std::string {
                assert( m_stringIndex < m_column.m_strings.size() );
                assert( m_pos <= m_end );
                return addIndentAndSuffix(line().substr(m_pos, m_len));
            }

            auto operator ++() -> iterator& {
                m_pos += m_len;
                if( m_pos < line().size() && line()[m_pos] == '\n' )
                    m_pos += 1;
                else
                    while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
                        ++m_pos;

                if( m_pos == line().size() ) {
                    m_pos = 0;
                    ++m_stringIndex;
                }
                if( m_stringIndex < m_column.m_strings.size() )
                    calcLength();
                return *this;
            }
            auto operator ++(int) -> iterator {
                iterator prev( *this );
                operator++();
                return prev;
            }

            auto operator ==( iterator const& other ) const -> bool {
                return
                    m_pos == other.m_pos &&
                    m_stringIndex == other.m_stringIndex &&
                    &m_column == &other.m_column;
            }
            auto operator !=( iterator const& other ) const -> bool {
                return !operator==( other );
            }
        };
        using const_iterator = iterator;

        explicit Column( std::string const& text ) { m_strings.push_back( text ); }

        auto width( size_t newWidth ) -> Column& {
            assert( newWidth > 0 );
            m_width = newWidth;
            return *this;
        }
        auto indent( size_t newIndent ) -> Column& {
            m_indent = newIndent;
            return *this;
        }
        auto initialIndent( size_t newIndent ) -> Column& {
            m_initialIndent = newIndent;
            return *this;
        }

        auto width() const -> size_t { return m_width; }
        auto begin() const -> iterator { return iterator( *this ); }
        auto end() const -> iterator { return { *this, m_strings.size() }; }

        inline friend std::ostream& operator << ( std::ostream& os, Column const& col ) {
            bool first = true;
            for( auto line : col ) {
                if( first )
                    first = false;
                else
                    os << "\n";
                os <<  line;
            }
            return os;
        }

        auto operator + ( Column const& other ) -> Columns;

        auto toString() const -> std::string {
            std::ostringstream oss;
            oss << *this;
            return oss.str();
        }
    };

    class Spacer : public Column {

    public:
        explicit Spacer( size_t spaceWidth ) : Column( "" ) {
            width( spaceWidth );
        }
    };

    class Columns {
        std::vector<Column> m_columns;

    public:

        class iterator {
            friend Columns;
            struct EndTag {};

            std::vector<Column> const& m_columns;
            std::vector<Column::iterator> m_iterators;
            size_t m_activeIterators;

            iterator( Columns const& columns, EndTag )
            :   m_columns( columns.m_columns ),
                m_activeIterators( 0 )
            {
                m_iterators.reserve( m_columns.size() );

                for( auto const& col : m_columns )
                    m_iterators.push_back( col.end() );
            }

        public:
            using difference_type = std::ptrdiff_t;
            using value_type = std::string;
            using pointer = value_type*;
            using reference = value_type&;
            using iterator_category = std::forward_iterator_tag;

            explicit iterator( Columns const& columns )
            :   m_columns( columns.m_columns ),
                m_activeIterators( m_columns.size() )
            {
                m_iterators.reserve( m_columns.size() );

                for( auto const& col : m_columns )
                    m_iterators.push_back( col.begin() );
            }

            auto operator ==( iterator const& other ) const -> bool {
                return m_iterators == other.m_iterators;
            }
            auto operator !=( iterator const& other ) const -> bool {
                return m_iterators != other.m_iterators;
            }
            auto operator *() const -> std::string {
                std::string row, padding;

                for( size_t i = 0; i < m_columns.size(); ++i ) {
                    auto width = m_columns[i].width();
                    if( m_iterators[i] != m_columns[i].end() ) {
                        std::string col = *m_iterators[i];
                        row += padding + col;
                        if( col.size() < width )
                            padding = std::string( width - col.size(), ' ' );
                        else
                            padding = "";
                    }
                    else {
                        padding += std::string( width, ' ' );
                    }
                }
                return row;
            }
            auto operator ++() -> iterator& {
                for( size_t i = 0; i < m_columns.size(); ++i ) {
                    if (m_iterators[i] != m_columns[i].end())
                        ++m_iterators[i];
                }
                return *this;
            }
            auto operator ++(int) -> iterator {
                iterator prev( *this );
                operator++();
                return prev;
            }
        };
        using const_iterator = iterator;

        auto begin() const -> iterator { return iterator( *this ); }
        auto end() const -> iterator { return { *this, iterator::EndTag() }; }

        auto operator += ( Column const& col ) -> Columns& {
            m_columns.push_back( col );
            return *this;
        }
        auto operator + ( Column const& col ) -> Columns {
            Columns combined = *this;
            combined += col;
            return combined;
        }

        inline friend std::ostream& operator << ( std::ostream& os, Columns const& cols ) {

            bool first = true;
            for( auto line : cols ) {
                if( first )
                    first = false;
                else
                    os << "\n";
                os << line;
            }
            return os;
        }

        auto toString() const -> std::string {
            std::ostringstream oss;
            oss << *this;
            return oss.str();
        }
    };

    inline auto Column::operator + ( Column const& other ) -> Columns {
        Columns cols;
        cols += *this;
        cols += other;
        return cols;
    }
}

#endif // TEXTFLOW_HPP_INCLUDED


================================================
FILE: third_party/catch.hpp
================================================
/*
 *  Catch v2.1.0
 *  Generated: 2018-01-10 13:51:15.378034
 *  ----------------------------------------------------------
 *  This file has been merged from multiple headers. Please don't edit it directly
 *  Copyright (c) 2018 Two Blue Cubes Ltd. All rights reserved.
 *
 *  Distributed under the Boost Software License, Version 1.0. (See accompanying
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
// start catch.hpp


#ifdef __clang__
#    pragma clang system_header
#elif defined __GNUC__
#    pragma GCC system_header
#endif

// start catch_suppress_warnings.h

#ifdef __clang__
#   ifdef __ICC // icpc defines the __clang__ macro
#       pragma warning(push)
#       pragma warning(disable: 161 1682)
#   else // __ICC
#       pragma clang diagnostic ignored "-Wunused-variable"
#       pragma clang diagnostic push
#       pragma clang diagnostic ignored "-Wpadded"
#       pragma clang diagnostic ignored "-Wswitch-enum"
#       pragma clang diagnostic ignored "-Wcovered-switch-default"
#    endif
#elif defined __GNUC__
#    pragma GCC diagnostic ignored "-Wunused-variable"
#    pragma GCC diagnostic ignored "-Wparentheses"
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wpadded"
#endif
// end catch_suppress_warnings.h
#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
#  define CATCH_IMPL
#  define CATCH_CONFIG_ALL_PARTS
#endif

// In the impl file, we want to have access to all parts of the headers
// Can also be used to sanely support PCHs
#if defined(CATCH_CONFIG_ALL_PARTS)
#  define CATCH_CONFIG_EXTERNAL_INTERFACES
#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
#    undef CATCH_CONFIG_DISABLE_MATCHERS
#  endif
#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
#endif

#if !defined(CATCH_CONFIG_IMPL_ONLY)
// start catch_platform.h

#ifdef __APPLE__
# include <TargetConditionals.h>
# if TARGET_OS_OSX == 1
#  define CATCH_PLATFORM_MAC
# elif TARGET_OS_IPHONE == 1
#  define CATCH_PLATFORM_IPHONE
# endif

#elif defined(linux) || defined(__linux) || defined(__linux__)
#  define CATCH_PLATFORM_LINUX

#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
#  define CATCH_PLATFORM_WINDOWS
#endif

// end catch_platform.h

#ifdef CATCH_IMPL
#  ifndef CLARA_CONFIG_MAIN
#    define CLARA_CONFIG_MAIN_NOT_DEFINED
#    define CLARA_CONFIG_MAIN
#  endif
#endif

// start catch_user_interfaces.h

namespace Catch {
    unsigned int rngSeed();
}

// end catch_user_interfaces.h
// start catch_tag_alias_autoregistrar.h

// start catch_common.h

// start catch_compiler_capabilities.h

// Detect a number of compiler features - by compiler
// The following features are defined:
//
// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
// ****************
// Note to maintainers: if new toggles are added please document them
// in configuration.md, too
// ****************

// In general each macro has a _NO_<feature name> form
// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
// Many features, at point of detection, define an _INTERNAL_ macro, so they
// can be combined, en-mass, with the _NO_ forms later.

#ifdef __cplusplus

#  if __cplusplus >= 201402L
#    define CATCH_CPP14_OR_GREATER
#  endif

#endif

#ifdef __clang__

#       define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
            _Pragma( "clang diagnostic push" ) \
            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
            _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
#       define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
            _Pragma( "clang diagnostic pop" )

#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
            _Pragma( "clang diagnostic push" ) \
            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
            _Pragma( "clang diagnostic pop" )

#endif // __clang__

////////////////////////////////////////////////////////////////////////////////
// We know some environments not to support full POSIX signals
#if defined(__CYGWIN__) || defined(__QNX__)

#   if !defined(CATCH_CONFIG_POSIX_SIGNALS)
#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
#   endif

#endif

#ifdef __OS400__
#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
#       define CATCH_CONFIG_COLOUR_NONE
#endif

////////////////////////////////////////////////////////////////////////////////
// Cygwin
#ifdef __CYGWIN__

// Required for some versions of Cygwin to declare gettimeofday
// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
#   define _BSD_SOURCE

#endif // __CYGWIN__

////////////////////////////////////////////////////////////////////////////////
// Visual C++
#ifdef _MSC_VER

// Universal Windows platform does not support SEH
// Or console colours (or console at all...)
#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
#    define CATCH_CONFIG_COLOUR_NONE
#  else
#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
#  endif

#endif // _MSC_VER

////////////////////////////////////////////////////////////////////////////////

// Use of __COUNTER__ is suppressed during code analysis in
// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
// handled by it.
// Otherwise all supported compilers support COUNTER macro,
// but user still might want to turn it off
#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
    #define CATCH_INTERNAL_CONFIG_COUNTER
#endif

#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
#   define CATCH_CONFIG_COUNTER
#endif
#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH)
#   define CATCH_CONFIG_WINDOWS_SEH
#endif
// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
#   define CATCH_CONFIG_POSIX_SIGNALS
#endif

#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
#   define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
#endif

// end catch_compiler_capabilities.h
#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
#ifdef CATCH_CONFIG_COUNTER
#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
#else
#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
#endif

#include <iosfwd>
#include <string>
#include <cstdint>

namespace Catch {

    struct CaseSensitive { enum Choice {
        Yes,
        No
    }; };

    class NonCopyable {
        NonCopyable( NonCopyable const& )              = delete;
        NonCopyable( NonCopyable && )                  = delete;
        NonCopyable& operator = ( NonCopyable const& ) = delete;
        NonCopyable& operator = ( NonCopyable && )     = delete;

    protected:
        NonCopyable();
        virtual ~NonCopyable();
    };

    struct SourceLineInfo {

        SourceLineInfo() = delete;
        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
        :   file( _file ),
            line( _line )
        {}

        SourceLineInfo( SourceLineInfo const& other )        = default;
        SourceLineInfo( SourceLineInfo && )                  = default;
        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
        SourceLineInfo& operator = ( SourceLineInfo && )     = default;

        bool empty() const noexcept;
        bool operator == ( SourceLineInfo const& other ) const noexcept;
        bool operator < ( SourceLineInfo const& other ) const noexcept;

        char const* file;
        std::size_t line;
    };

    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );

    // Use this in variadic streaming macros to allow
    //    >> +StreamEndStop
    // as well as
    //    >> stuff +StreamEndStop
    struct StreamEndStop {
        std::string operator+() const;
    };
    template<typename T>
    T const& operator + ( T const& value, StreamEndStop ) {
        return value;
    }
}

#define CATCH_INTERNAL_LINEINFO \
    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )

// end catch_common.h
namespace Catch {

    struct RegistrarForTagAliases {
        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
    };

} // end namespace Catch

#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS

// end catch_tag_alias_autoregistrar.h
// start catch_test_registry.h

// start catch_interfaces_testcase.h

#include <vector>
#include <memory>

namespace Catch {

    class TestSpec;

    struct ITestInvoker {
        virtual void invoke () const = 0;
        virtual ~ITestInvoker();
    };

    using ITestCasePtr = std::shared_ptr<ITestInvoker>;

    class TestCase;
    struct IConfig;

    struct ITestCaseRegistry {
        virtual ~ITestCaseRegistry();
        virtual std::vector<TestCase> const& getAllTests() const = 0;
        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
    };

    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );

}

// end catch_interfaces_testcase.h
// start catch_stringref.h

#include <cstddef>
#include <string>
#include <iosfwd>

namespace Catch {

    class StringData;

    /// A non-owning string class (similar to the forthcoming std::string_view)
    /// Note that, because a StringRef may be a substring of another string,
    /// it may not be null terminated. c_str() must return a null terminated
    /// string, however, and so the StringRef will internally take ownership
    /// (taking a copy), if necessary. In theory this ownership is not externally
    /// visible - but it does mean (substring) StringRefs should not be shared between
    /// threads.
    class StringRef {
    public:
        using size_type = std::size_t;

    private:
        friend struct StringRefTestAccess;

        char const* m_start;
        size_type m_size;

        char* m_data = nullptr;

        void takeOwnership();

        static constexpr char const* const s_empty = "";

    public: // construction/ assignment
        StringRef() noexcept
        :   StringRef( s_empty, 0 )
        {}

        StringRef( StringRef const& other ) noexcept
        :   m_start( other.m_start ),
            m_size( other.m_size )
        {}

        StringRef( StringRef&& other ) noexcept
        :   m_start( other.m_start ),
            m_size( other.m_size ),
            m_data( other.m_data )
        {
            other.m_data = nullptr;
        }

        StringRef( char const* rawChars ) noexcept;

        StringRef( char const* rawChars, size_type size ) noexcept
        :   m_start( rawChars ),
            m_size( size )
        {}

        StringRef( std::string const& stdString ) noexcept
        :   m_start( stdString.c_str() ),
            m_size( stdString.size() )
        {}

        ~StringRef() noexcept {
            delete[] m_data;
        
Download .txt
gitextract_vb6dyj94/

├── .gitattributes
├── .gitignore
├── .travis.yml
├── CMake/
│   ├── FindGcov.cmake
│   ├── FindLcov.cmake
│   ├── Findcodecov.cmake
│   └── llvm-cov-wrapper
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── LICENSE.txt
├── README.md
├── Roadmap.md
├── appveyor.yml
├── codecov.yml
├── docs/
│   └── release-notes.md
├── include/
│   ├── clara.hpp
│   └── clara_textflow.hpp
├── misc/
│   ├── CMakeLists.txt
│   ├── appveyorBuildConfigurationScript.bat
│   ├── appveyorMergeCoverageScript.py
│   ├── appveyorTestRunScript.bat
│   ├── coverage-helper.cpp
│   └── installOpenCppCoverage.ps1
├── scripts/
│   ├── embed.py
│   ├── embedTextFlow.py
│   ├── release.py
│   └── stitch.py
├── single_include/
│   └── clara.hpp
├── src/
│   ├── ClaraTests.cpp
│   └── main.cpp
└── third_party/
    ├── TextFlow.hpp
    └── catch.hpp
Copy disabled (too large) Download .txt
Showing preview only (29,886K chars total). Download the full file to get everything.
SYMBOL INDEX (1460 symbols across 10 files)

FILE: include/clara.hpp
  type clara (line 44) | namespace clara {
    type detail (line 45) | namespace detail {
      type UnaryLambdaTraits (line 49) | struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator(...
      type UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> (line 57) | struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
      class TokenStream (line 63) | class TokenStream
        method loadBuffer (line 111) | void loadBuffer() {
        method TokenStream (line 143) | explicit TokenStream( Args const &args ) : TokenStream( args.m_arg...
        method TokenStream (line 145) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEn...
        method count (line 153) | auto count() const -> size_t { return m_tokenBuffer.size() + (itEn...
      class Args (line 66) | class Args {
        method Args (line 72) | Args( int argc, char const* const* argv )
        method Args (line 76) | Args( std::initializer_list<std::string> args )
        method exeName (line 81) | auto exeName() const -> std::string {
      type TokenType (line 88) | enum class TokenType {
      type Token (line 91) | struct Token {
      function isOptPrefix (line 96) | inline auto isOptPrefix( char c ) -> bool {
      class TokenStream (line 105) | class TokenStream {
        method loadBuffer (line 111) | void loadBuffer() {
        method TokenStream (line 143) | explicit TokenStream( Args const &args ) : TokenStream( args.m_arg...
        method TokenStream (line 145) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEn...
        method count (line 153) | auto count() const -> size_t { return m_tokenBuffer.size() + (itEn...
      class ResultBase (line 178) | class ResultBase {
        type Type (line 180) | enum Type {
        method ResultBase (line 185) | ResultBase( Type type ) : m_type( type ) {}
      class ResultValueBase (line 194) | class ResultValueBase : public ResultBase {
        method value (line 196) | auto value() const -> T const & {
        method ResultValueBase (line 202) | ResultValueBase( Type type ) : ResultBase( type ) {}
        method ResultValueBase (line 204) | ResultValueBase( ResultValueBase const &other ) : ResultBase( othe...
        method ResultValueBase (line 209) | ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
      class ResultValueBase<void> (line 233) | class ResultValueBase<void> : public ResultBase {
      class BasicResult (line 239) | class BasicResult : public ResultValueBase<T> {
        method BasicResult (line 242) | explicit BasicResult( BasicResult<U> const &other )
        method ok (line 250) | static auto ok( U const &value ) -> BasicResult { return { ResultB...
        method ok (line 251) | static auto ok() -> BasicResult { return { ResultBase::Ok }; }
        method logicError (line 252) | static auto logicError( std::string const &message ) -> BasicResul...
        method runtimeError (line 253) | static auto runtimeError( std::string const &message ) -> BasicRes...
        method type (line 256) | auto type() const -> ResultBase::Type { return m_type; }
        method errorMessage (line 257) | auto errorMessage() const -> std::string { return m_errorMessage; }
        method enforceOk (line 260) | void enforceOk() const override {
        method BasicResult (line 272) | BasicResult( ResultBase::Type type, std::string const &message )
      type ParseResultType (line 283) | enum class ParseResultType {
      class ParseState (line 287) | class ParseState {
        method ParseState (line 290) | ParseState( ParseResultType type, TokenStream const &remainingToke...
        method type (line 295) | auto type() const -> ParseResultType { return m_type; }
        method remainingTokens (line 296) | auto remainingTokens() const -> TokenStream { return m_remainingTo...
      type HelpColumns (line 307) | struct HelpColumns {
      function convertInto (line 313) | inline auto convertInto( std::string const &source, T& target ) -> P...
      function convertInto (line 322) | inline auto convertInto( std::string const &source, std::string& tar...
      function convertInto (line 326) | inline auto convertInto( std::string const &source, bool &target ) -...
      function convertInto (line 339) | inline auto convertInto( std::string const &source, CLARA_CONFIG_OPT...
      type NonCopyable (line 348) | struct NonCopyable {
        method NonCopyable (line 349) | NonCopyable() = default;
        method NonCopyable (line 350) | NonCopyable( NonCopyable const & ) = delete;
        method NonCopyable (line 351) | NonCopyable( NonCopyable && ) = delete;
        method NonCopyable (line 352) | NonCopyable &operator=( NonCopyable const & ) = delete;
        method NonCopyable (line 353) | NonCopyable &operator=( NonCopyable && ) = delete;
      type BoundRef (line 356) | struct BoundRef : NonCopyable {
        method isContainer (line 358) | virtual auto isContainer() const -> bool { return false; }
        method isFlag (line 359) | virtual auto isFlag() const -> bool { return false; }
      type BoundValueRefBase (line 361) | struct BoundValueRefBase : BoundRef {
      type BoundFlagRefBase (line 364) | struct BoundFlagRefBase : BoundRef {
        method isFlag (line 366) | virtual auto isFlag() const -> bool { return true; }
      type BoundValueRef (line 370) | struct BoundValueRef : BoundValueRefBase {
        method BoundValueRef (line 373) | explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
        method setValue (line 375) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundValueRef<std::vector<T>> (line 381) | struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
        method BoundValueRef (line 384) | explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
        method isContainer (line 386) | auto isContainer() const -> bool override { return true; }
        method setValue (line 388) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundFlagRef (line 397) | struct BoundFlagRef : BoundFlagRefBase {
        method BoundFlagRef (line 400) | explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
        method setFlag (line 402) | auto setFlag( bool flag ) -> ParserResult override {
      type LambdaInvoker (line 409) | struct LambdaInvoker {
        method invoke (line 413) | static auto invoke( L const &lambda, ArgType const &arg ) -> Parse...
      type LambdaInvoker<void> (line 419) | struct LambdaInvoker<void> {
        method invoke (line 421) | static auto invoke( L const &lambda, ArgType const &arg ) -> Parse...
      function invokeLambda (line 428) | inline auto invokeLambda( L const &lambda, std::string const &arg ) ...
      type BoundLambda (line 438) | struct BoundLambda : BoundValueRefBase {
        method BoundLambda (line 442) | explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
        method setValue (line 444) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundFlagLambda (line 450) | struct BoundFlagLambda : BoundFlagRefBase {
        method BoundFlagLambda (line 456) | explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
        method setFlag (line 458) | auto setFlag( bool flag ) -> ParserResult override {
      type Optionality (line 463) | enum class Optionality { Optional, Required }
      type Parser (line 465) | struct Parser
        method getHelpColumns (line 772) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method writeToStream (line 781) | void writeToStream( std::ostream &os ) const {
        method validate (line 827) | auto validate() const -> Result override {
        method parse (line 843) | auto parse( std::string const& exeName, TokenStream const &tokens ...
      class ParserBase (line 467) | class ParserBase {
        method validate (line 470) | virtual auto validate() const -> Result { return Result::ok(); }
        method cardinality (line 472) | virtual auto cardinality() const -> size_t { return 1; }
        method parse (line 474) | auto parse( Args const &args ) const -> InternalParseResult {
      class ComposableParserImpl (line 480) | class ComposableParserImpl : public ParserBase {
      class ParserRefImpl (line 491) | class ParserRefImpl : public ComposableParserImpl<DerivedT> {
        method ParserRefImpl (line 498) | explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m...
        method ParserRefImpl (line 502) | ParserRefImpl( T &ref, std::string const &hint )
        method ParserRefImpl (line 508) | ParserRefImpl( LambdaT const &ref, std::string const &hint )
        method optional (line 518) | auto optional() -> DerivedT & {
        method required (line 523) | auto required() -> DerivedT & {
        method isOptional (line 528) | auto isOptional() const -> bool {
        method cardinality (line 532) | auto cardinality() const -> size_t override {
        method hint (line 539) | auto hint() const -> std::string { return m_hint; }
      class ExeName (line 542) | class ExeName : public ComposableParserImpl<ExeName> {
        method makeRef (line 547) | static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<Boun...
        method ExeName (line 552) | ExeName() : m_name( std::make_shared<std::string>( "<executable>" ...
        method ExeName (line 554) | explicit ExeName( std::string &ref ) : ExeName() {
        method ExeName (line 559) | explicit ExeName( LambdaT const& lambda ) : ExeName() {
        method parse (line 564) | auto parse( std::string const&, TokenStream const &tokens ) const ...
        method name (line 568) | auto name() const -> std::string { return *m_name; }
        method set (line 569) | auto set( std::string const& newName ) -> ParserResult {
      class Arg (line 584) | class Arg : public ParserRefImpl<Arg> {
        method parse (line 588) | auto parse( std::string const &, TokenStream const &tokens ) const...
      function normaliseOpt (line 609) | inline auto normaliseOpt( std::string const &optName ) -> std::string {
      class Opt (line 618) | class Opt : public ParserRefImpl<Opt> {
        method Opt (line 624) | explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shar...
        method Opt (line 626) | explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundF...
        method Opt (line 629) | Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl...
        method Opt (line 632) | Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ...
        method getHelpColumns (line 639) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method isMatch (line 654) | auto isMatch( std::string const &optToken ) const -> bool {
        method parse (line 665) | auto parse( std::string const&, TokenStream const &tokens ) const ...
        method validate (line 701) | auto validate() const -> Result override {
      type Help (line 719) | struct Help : Opt {
        method Help (line 720) | Help( bool &showHelpFlag )
      type Parser (line 734) | struct Parser : ParserBase {
        method getHelpColumns (line 772) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method writeToStream (line 781) | void writeToStream( std::ostream &os ) const {
        method validate (line 827) | auto validate() const -> Result override {
        method parse (line 843) | auto parse( std::string const& exeName, TokenStream const &tokens ...
  type UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> (line 52) | struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {

FILE: include/clara_textflow.hpp
  type clara (line 23) | namespace clara { namespace TextFlow {
    type TextFlow (line 23) | namespace TextFlow {
      function isWhitespace (line 25) | inline auto isWhitespace( char c ) -> bool {
      function isBreakableBefore (line 29) | inline auto isBreakableBefore( char c ) -> bool {
      function isBreakableAfter (line 33) | inline auto isBreakableAfter( char c ) -> bool {
      class Columns (line 38) | class Columns
        class iterator (line 221) | class iterator {
          type EndTag (line 223) | struct EndTag {}
          method iterator (line 229) | iterator( Columns const& columns, EndTag )
          method iterator (line 246) | explicit iterator( Columns const& columns )
        method begin (line 296) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 297) | auto end() const -> iterator { return { *this, iterator::EndTag() ...
        method friend (line 309) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 322) | auto toString() const -> std::string {
      class Column (line 40) | class Column {
        class iterator (line 47) | class iterator {
          method iterator (line 58) | iterator( Column const& column, size_t stringIndex )
          method line (line 63) | auto line() const -> std::string const& { return m_column.m_stri...
          method isBoundary (line 65) | auto isBoundary( size_t at ) const -> bool {
          method calcLength (line 75) | void calcLength() {
          method indent (line 103) | auto indent() const -> size_t {
          method addIndentAndSuffix (line 108) | auto addIndentAndSuffix(std::string const &plain) const -> std::...
          method iterator (line 119) | explicit iterator( Column const& column ) : m_column( column ) {
        method Column (line 167) | explicit Column( std::string const& text ) { m_strings.push_back( ...
        method width (line 169) | auto width( size_t newWidth ) -> Column& {
        method indent (line 174) | auto indent( size_t newIndent ) -> Column& {
        method initialIndent (line 178) | auto initialIndent( size_t newIndent ) -> Column& {
        method width (line 183) | auto width() const -> size_t { return m_width; }
        method begin (line 184) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 185) | auto end() const -> iterator { return { *this, m_strings.size() }; }
        method friend (line 187) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 201) | auto toString() const -> std::string {
      class Spacer (line 208) | class Spacer : public Column {
        method Spacer (line 211) | explicit Spacer( size_t spaceWidth ) : Column( "" ) {
      class Columns (line 216) | class Columns {
        class iterator (line 221) | class iterator {
          type EndTag (line 223) | struct EndTag {}
          method iterator (line 229) | iterator( Columns const& columns, EndTag )
          method iterator (line 246) | explicit iterator( Columns const& columns )
        method begin (line 296) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 297) | auto end() const -> iterator { return { *this, iterator::EndTag() ...
        method friend (line 309) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 322) | auto toString() const -> std::string {

FILE: misc/coverage-helper.cpp
  function create_empty_file (line 14) | void create_empty_file(std::string const& path) {
  function to_lower (line 23) | std::string to_lower(std::string in) {
  function starts_with (line 30) | bool starts_with(std::string const& str, std::string const& pref) {
  function parse_log_file_arg (line 34) | int parse_log_file_arg(std::string const& arg) {
  function project_path (line 47) | std::string project_path(std::string path) {
  function windowsify_path (line 59) | std::string windowsify_path(std::string path) {
  function exec_cmd (line 68) | void exec_cmd(std::string const& cmd, int log_num, std::string const& pa...
  function main (line 96) | int main(int argc, char** argv) {

FILE: scripts/embed.py
  class LineMapper (line 20) | class LineMapper:
    method __init__ (line 21) | def __init__( self, idMap, outerNamespace ):
    method replaceId (line 25) | def replaceId( self, lineNo, id ):
    method mapLine (line 36) | def mapLine( self, lineNo, line ):
    method mapFile (line 54) | def mapFile(self, filenameIn, filenameOut ):

FILE: scripts/release.py
  function precheck (line 17) | def precheck():
  class Version (line 28) | class Version:
    method __init__ (line 29) | def __init__(self):
    method nonDevelopRelease (line 47) | def nonDevelopRelease(self):
    method developBuild (line 51) | def developBuild(self):
    method incrementBuildNumber (line 58) | def incrementBuildNumber(self):
    method incrementPatchNumber (line 62) | def incrementPatchNumber(self):
    method incrementMinorVersion (line 66) | def incrementMinorVersion(self):
    method incrementMajorVersion (line 71) | def incrementMajorVersion(self):
    method getVersionString (line 77) | def getVersionString(self):
    method updateHeader (line 83) | def updateHeader(self):
    method updateReadme (line 97) | def updateReadme(self):
  function usage (line 115) | def usage():

FILE: scripts/stitch.py
  class FileParser (line 54) | class FileParser:
    method __init__ (line 57) | def __init__( self, filename ):
    method findHeader (line 60) | def findHeader( self, headerFile ):
    method parse (line 88) | def parse( self ):
    method handleNonPP (line 96) | def handleNonPP( self, line ):
    method handlePreprocessor (line 100) | def handlePreprocessor( self, line ):
    method handleInclude (line 107) | def handleInclude( self, line ):
    method handleNonIncludePP (line 133) | def handleNonIncludePP( self, line ):
    method handleDefine (line 155) | def handleDefine( self, define, value ):
    method handleUndef (line 159) | def handleUndef( self, define ):
    method handleIfdefCommon (line 163) | def handleIfdefCommon( self, line ):
    method handleEndif (line 180) | def handleEndif( self, trailing ):
    method handleElse (line 188) | def handleElse( self ):
    method handleIfndef (line 194) | def handleIfndef( self, define ):
    method handleIfdef (line 199) | def handleIfdef( self, define ):
    method handleIf (line 204) | def handleIf( self, trailing ):
    method writeLine (line 213) | def writeLine( self, line ):

FILE: single_include/clara.hpp
  type clara (line 55) | namespace clara { namespace TextFlow {
    type TextFlow (line 55) | namespace TextFlow {
      function isWhitespace (line 57) | inline auto isWhitespace( char c ) -> bool {
      function isBreakableBefore (line 61) | inline auto isBreakableBefore( char c ) -> bool {
      function isBreakableAfter (line 65) | inline auto isBreakableAfter( char c ) -> bool {
      class Columns (line 70) | class Columns
        class iterator (line 253) | class iterator {
          type EndTag (line 255) | struct EndTag {}
          method iterator (line 261) | iterator( Columns const& columns, EndTag )
          method iterator (line 278) | explicit iterator( Columns const& columns )
        method begin (line 328) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 329) | auto end() const -> iterator { return { *this, iterator::EndTag() ...
        method friend (line 341) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 354) | auto toString() const -> std::string {
      class Column (line 72) | class Column {
        class iterator (line 79) | class iterator {
          method iterator (line 90) | iterator( Column const& column, size_t stringIndex )
          method line (line 95) | auto line() const -> std::string const& { return m_column.m_stri...
          method isBoundary (line 97) | auto isBoundary( size_t at ) const -> bool {
          method calcLength (line 107) | void calcLength() {
          method indent (line 135) | auto indent() const -> size_t {
          method addIndentAndSuffix (line 140) | auto addIndentAndSuffix(std::string const &plain) const -> std::...
          method iterator (line 151) | explicit iterator( Column const& column ) : m_column( column ) {
        method Column (line 199) | explicit Column( std::string const& text ) { m_strings.push_back( ...
        method width (line 201) | auto width( size_t newWidth ) -> Column& {
        method indent (line 206) | auto indent( size_t newIndent ) -> Column& {
        method initialIndent (line 210) | auto initialIndent( size_t newIndent ) -> Column& {
        method width (line 215) | auto width() const -> size_t { return m_width; }
        method begin (line 216) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 217) | auto end() const -> iterator { return { *this, m_strings.size() }; }
        method friend (line 219) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 233) | auto toString() const -> std::string {
      class Spacer (line 240) | class Spacer : public Column {
        method Spacer (line 243) | explicit Spacer( size_t spaceWidth ) : Column( "" ) {
      class Columns (line 248) | class Columns {
        class iterator (line 253) | class iterator {
          type EndTag (line 255) | struct EndTag {}
          method iterator (line 261) | iterator( Columns const& columns, EndTag )
          method iterator (line 278) | explicit iterator( Columns const& columns )
        method begin (line 328) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 329) | auto end() const -> iterator { return { *this, iterator::EndTag() ...
        method friend (line 341) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 354) | auto toString() const -> std::string {
    type detail (line 384) | namespace detail {
      type UnaryLambdaTraits (line 388) | struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator(...
      type UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> (line 396) | struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
      class TokenStream (line 402) | class TokenStream
        method loadBuffer (line 450) | void loadBuffer() {
        method TokenStream (line 482) | explicit TokenStream( Args const &args ) : TokenStream( args.m_arg...
        method TokenStream (line 484) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEn...
        method count (line 492) | auto count() const -> size_t { return m_tokenBuffer.size() + (itEn...
      class Args (line 405) | class Args {
        method Args (line 411) | Args( int argc, char const* const* argv )
        method Args (line 415) | Args( std::initializer_list<std::string> args )
        method exeName (line 420) | auto exeName() const -> std::string {
      type TokenType (line 427) | enum class TokenType {
      type Token (line 430) | struct Token {
      function isOptPrefix (line 435) | inline auto isOptPrefix( char c ) -> bool {
      class TokenStream (line 444) | class TokenStream {
        method loadBuffer (line 450) | void loadBuffer() {
        method TokenStream (line 482) | explicit TokenStream( Args const &args ) : TokenStream( args.m_arg...
        method TokenStream (line 484) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEn...
        method count (line 492) | auto count() const -> size_t { return m_tokenBuffer.size() + (itEn...
      class ResultBase (line 517) | class ResultBase {
        type Type (line 519) | enum Type {
        method ResultBase (line 524) | ResultBase( Type type ) : m_type( type ) {}
      class ResultValueBase (line 533) | class ResultValueBase : public ResultBase {
        method value (line 535) | auto value() const -> T const & {
        method ResultValueBase (line 541) | ResultValueBase( Type type ) : ResultBase( type ) {}
        method ResultValueBase (line 543) | ResultValueBase( ResultValueBase const &other ) : ResultBase( othe...
        method ResultValueBase (line 548) | ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
      class ResultValueBase<void> (line 572) | class ResultValueBase<void> : public ResultBase {
      class BasicResult (line 578) | class BasicResult : public ResultValueBase<T> {
        method BasicResult (line 581) | explicit BasicResult( BasicResult<U> const &other )
        method ok (line 589) | static auto ok( U const &value ) -> BasicResult { return { ResultB...
        method ok (line 590) | static auto ok() -> BasicResult { return { ResultBase::Ok }; }
        method logicError (line 591) | static auto logicError( std::string const &message ) -> BasicResul...
        method runtimeError (line 592) | static auto runtimeError( std::string const &message ) -> BasicRes...
        method type (line 595) | auto type() const -> ResultBase::Type { return m_type; }
        method errorMessage (line 596) | auto errorMessage() const -> std::string { return m_errorMessage; }
        method enforceOk (line 599) | void enforceOk() const override {
        method BasicResult (line 611) | BasicResult( ResultBase::Type type, std::string const &message )
      type ParseResultType (line 622) | enum class ParseResultType {
      class ParseState (line 626) | class ParseState {
        method ParseState (line 629) | ParseState( ParseResultType type, TokenStream const &remainingToke...
        method type (line 634) | auto type() const -> ParseResultType { return m_type; }
        method remainingTokens (line 635) | auto remainingTokens() const -> TokenStream { return m_remainingTo...
      type HelpColumns (line 646) | struct HelpColumns {
      function convertInto (line 652) | inline auto convertInto( std::string const &source, T& target ) -> P...
      function convertInto (line 661) | inline auto convertInto( std::string const &source, std::string& tar...
      function convertInto (line 665) | inline auto convertInto( std::string const &source, bool &target ) -...
      function convertInto (line 678) | inline auto convertInto( std::string const &source, CLARA_CONFIG_OPT...
      type NonCopyable (line 687) | struct NonCopyable {
        method NonCopyable (line 688) | NonCopyable() = default;
        method NonCopyable (line 689) | NonCopyable( NonCopyable const & ) = delete;
        method NonCopyable (line 690) | NonCopyable( NonCopyable && ) = delete;
        method NonCopyable (line 691) | NonCopyable &operator=( NonCopyable const & ) = delete;
        method NonCopyable (line 692) | NonCopyable &operator=( NonCopyable && ) = delete;
      type BoundRef (line 695) | struct BoundRef : NonCopyable {
        method isContainer (line 697) | virtual auto isContainer() const -> bool { return false; }
        method isFlag (line 698) | virtual auto isFlag() const -> bool { return false; }
      type BoundValueRefBase (line 700) | struct BoundValueRefBase : BoundRef {
      type BoundFlagRefBase (line 703) | struct BoundFlagRefBase : BoundRef {
        method isFlag (line 705) | virtual auto isFlag() const -> bool { return true; }
      type BoundValueRef (line 709) | struct BoundValueRef : BoundValueRefBase {
        method BoundValueRef (line 712) | explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
        method setValue (line 714) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundValueRef<std::vector<T>> (line 720) | struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
        method BoundValueRef (line 723) | explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
        method isContainer (line 725) | auto isContainer() const -> bool override { return true; }
        method setValue (line 727) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundFlagRef (line 736) | struct BoundFlagRef : BoundFlagRefBase {
        method BoundFlagRef (line 739) | explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
        method setFlag (line 741) | auto setFlag( bool flag ) -> ParserResult override {
      type LambdaInvoker (line 748) | struct LambdaInvoker {
        method invoke (line 752) | static auto invoke( L const &lambda, ArgType const &arg ) -> Parse...
      type LambdaInvoker<void> (line 758) | struct LambdaInvoker<void> {
        method invoke (line 760) | static auto invoke( L const &lambda, ArgType const &arg ) -> Parse...
      function invokeLambda (line 767) | inline auto invokeLambda( L const &lambda, std::string const &arg ) ...
      type BoundLambda (line 777) | struct BoundLambda : BoundValueRefBase {
        method BoundLambda (line 781) | explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
        method setValue (line 783) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundFlagLambda (line 789) | struct BoundFlagLambda : BoundFlagRefBase {
        method BoundFlagLambda (line 795) | explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
        method setFlag (line 797) | auto setFlag( bool flag ) -> ParserResult override {
      type Optionality (line 802) | enum class Optionality { Optional, Required }
      type Parser (line 804) | struct Parser
        method getHelpColumns (line 1111) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method writeToStream (line 1120) | void writeToStream( std::ostream &os ) const {
        method validate (line 1166) | auto validate() const -> Result override {
        method parse (line 1182) | auto parse( std::string const& exeName, TokenStream const &tokens ...
      class ParserBase (line 806) | class ParserBase {
        method validate (line 809) | virtual auto validate() const -> Result { return Result::ok(); }
        method cardinality (line 811) | virtual auto cardinality() const -> size_t { return 1; }
        method parse (line 813) | auto parse( Args const &args ) const -> InternalParseResult {
      class ComposableParserImpl (line 819) | class ComposableParserImpl : public ParserBase {
      class ParserRefImpl (line 830) | class ParserRefImpl : public ComposableParserImpl<DerivedT> {
        method ParserRefImpl (line 837) | explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m...
        method ParserRefImpl (line 841) | ParserRefImpl( T &ref, std::string const &hint )
        method ParserRefImpl (line 847) | ParserRefImpl( LambdaT const &ref, std::string const &hint )
        method optional (line 857) | auto optional() -> DerivedT & {
        method required (line 862) | auto required() -> DerivedT & {
        method isOptional (line 867) | auto isOptional() const -> bool {
        method cardinality (line 871) | auto cardinality() const -> size_t override {
        method hint (line 878) | auto hint() const -> std::string { return m_hint; }
      class ExeName (line 881) | class ExeName : public ComposableParserImpl<ExeName> {
        method makeRef (line 886) | static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<Boun...
        method ExeName (line 891) | ExeName() : m_name( std::make_shared<std::string>( "<executable>" ...
        method ExeName (line 893) | explicit ExeName( std::string &ref ) : ExeName() {
        method ExeName (line 898) | explicit ExeName( LambdaT const& lambda ) : ExeName() {
        method parse (line 903) | auto parse( std::string const&, TokenStream const &tokens ) const ...
        method name (line 907) | auto name() const -> std::string { return *m_name; }
        method set (line 908) | auto set( std::string const& newName ) -> ParserResult {
      class Arg (line 923) | class Arg : public ParserRefImpl<Arg> {
        method parse (line 927) | auto parse( std::string const &, TokenStream const &tokens ) const...
      function normaliseOpt (line 948) | inline auto normaliseOpt( std::string const &optName ) -> std::string {
      class Opt (line 957) | class Opt : public ParserRefImpl<Opt> {
        method Opt (line 963) | explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shar...
        method Opt (line 965) | explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundF...
        method Opt (line 968) | Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl...
        method Opt (line 971) | Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ...
        method getHelpColumns (line 978) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method isMatch (line 993) | auto isMatch( std::string const &optToken ) const -> bool {
        method parse (line 1004) | auto parse( std::string const&, TokenStream const &tokens ) const ...
        method validate (line 1040) | auto validate() const -> Result override {
      type Help (line 1058) | struct Help : Opt {
        method Help (line 1059) | Help( bool &showHelpFlag )
      type Parser (line 1073) | struct Parser : ParserBase {
        method getHelpColumns (line 1111) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method writeToStream (line 1120) | void writeToStream( std::ostream &os ) const {
        method validate (line 1166) | auto validate() const -> Result override {
        method parse (line 1182) | auto parse( std::string const& exeName, TokenStream const &tokens ...
  type clara (line 383) | namespace clara {
    type TextFlow (line 55) | namespace TextFlow {
      function isWhitespace (line 57) | inline auto isWhitespace( char c ) -> bool {
      function isBreakableBefore (line 61) | inline auto isBreakableBefore( char c ) -> bool {
      function isBreakableAfter (line 65) | inline auto isBreakableAfter( char c ) -> bool {
      class Columns (line 70) | class Columns
        class iterator (line 253) | class iterator {
          type EndTag (line 255) | struct EndTag {}
          method iterator (line 261) | iterator( Columns const& columns, EndTag )
          method iterator (line 278) | explicit iterator( Columns const& columns )
        method begin (line 328) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 329) | auto end() const -> iterator { return { *this, iterator::EndTag() ...
        method friend (line 341) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 354) | auto toString() const -> std::string {
      class Column (line 72) | class Column {
        class iterator (line 79) | class iterator {
          method iterator (line 90) | iterator( Column const& column, size_t stringIndex )
          method line (line 95) | auto line() const -> std::string const& { return m_column.m_stri...
          method isBoundary (line 97) | auto isBoundary( size_t at ) const -> bool {
          method calcLength (line 107) | void calcLength() {
          method indent (line 135) | auto indent() const -> size_t {
          method addIndentAndSuffix (line 140) | auto addIndentAndSuffix(std::string const &plain) const -> std::...
          method iterator (line 151) | explicit iterator( Column const& column ) : m_column( column ) {
        method Column (line 199) | explicit Column( std::string const& text ) { m_strings.push_back( ...
        method width (line 201) | auto width( size_t newWidth ) -> Column& {
        method indent (line 206) | auto indent( size_t newIndent ) -> Column& {
        method initialIndent (line 210) | auto initialIndent( size_t newIndent ) -> Column& {
        method width (line 215) | auto width() const -> size_t { return m_width; }
        method begin (line 216) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 217) | auto end() const -> iterator { return { *this, m_strings.size() }; }
        method friend (line 219) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 233) | auto toString() const -> std::string {
      class Spacer (line 240) | class Spacer : public Column {
        method Spacer (line 243) | explicit Spacer( size_t spaceWidth ) : Column( "" ) {
      class Columns (line 248) | class Columns {
        class iterator (line 253) | class iterator {
          type EndTag (line 255) | struct EndTag {}
          method iterator (line 261) | iterator( Columns const& columns, EndTag )
          method iterator (line 278) | explicit iterator( Columns const& columns )
        method begin (line 328) | auto begin() const -> iterator { return iterator( *this ); }
        method end (line 329) | auto end() const -> iterator { return { *this, iterator::EndTag() ...
        method friend (line 341) | inline friend std::ostream& operator << ( std::ostream& os, Column...
        method toString (line 354) | auto toString() const -> std::string {
    type detail (line 384) | namespace detail {
      type UnaryLambdaTraits (line 388) | struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator(...
      type UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> (line 396) | struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
      class TokenStream (line 402) | class TokenStream
        method loadBuffer (line 450) | void loadBuffer() {
        method TokenStream (line 482) | explicit TokenStream( Args const &args ) : TokenStream( args.m_arg...
        method TokenStream (line 484) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEn...
        method count (line 492) | auto count() const -> size_t { return m_tokenBuffer.size() + (itEn...
      class Args (line 405) | class Args {
        method Args (line 411) | Args( int argc, char const* const* argv )
        method Args (line 415) | Args( std::initializer_list<std::string> args )
        method exeName (line 420) | auto exeName() const -> std::string {
      type TokenType (line 427) | enum class TokenType {
      type Token (line 430) | struct Token {
      function isOptPrefix (line 435) | inline auto isOptPrefix( char c ) -> bool {
      class TokenStream (line 444) | class TokenStream {
        method loadBuffer (line 450) | void loadBuffer() {
        method TokenStream (line 482) | explicit TokenStream( Args const &args ) : TokenStream( args.m_arg...
        method TokenStream (line 484) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEn...
        method count (line 492) | auto count() const -> size_t { return m_tokenBuffer.size() + (itEn...
      class ResultBase (line 517) | class ResultBase {
        type Type (line 519) | enum Type {
        method ResultBase (line 524) | ResultBase( Type type ) : m_type( type ) {}
      class ResultValueBase (line 533) | class ResultValueBase : public ResultBase {
        method value (line 535) | auto value() const -> T const & {
        method ResultValueBase (line 541) | ResultValueBase( Type type ) : ResultBase( type ) {}
        method ResultValueBase (line 543) | ResultValueBase( ResultValueBase const &other ) : ResultBase( othe...
        method ResultValueBase (line 548) | ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
      class ResultValueBase<void> (line 572) | class ResultValueBase<void> : public ResultBase {
      class BasicResult (line 578) | class BasicResult : public ResultValueBase<T> {
        method BasicResult (line 581) | explicit BasicResult( BasicResult<U> const &other )
        method ok (line 589) | static auto ok( U const &value ) -> BasicResult { return { ResultB...
        method ok (line 590) | static auto ok() -> BasicResult { return { ResultBase::Ok }; }
        method logicError (line 591) | static auto logicError( std::string const &message ) -> BasicResul...
        method runtimeError (line 592) | static auto runtimeError( std::string const &message ) -> BasicRes...
        method type (line 595) | auto type() const -> ResultBase::Type { return m_type; }
        method errorMessage (line 596) | auto errorMessage() const -> std::string { return m_errorMessage; }
        method enforceOk (line 599) | void enforceOk() const override {
        method BasicResult (line 611) | BasicResult( ResultBase::Type type, std::string const &message )
      type ParseResultType (line 622) | enum class ParseResultType {
      class ParseState (line 626) | class ParseState {
        method ParseState (line 629) | ParseState( ParseResultType type, TokenStream const &remainingToke...
        method type (line 634) | auto type() const -> ParseResultType { return m_type; }
        method remainingTokens (line 635) | auto remainingTokens() const -> TokenStream { return m_remainingTo...
      type HelpColumns (line 646) | struct HelpColumns {
      function convertInto (line 652) | inline auto convertInto( std::string const &source, T& target ) -> P...
      function convertInto (line 661) | inline auto convertInto( std::string const &source, std::string& tar...
      function convertInto (line 665) | inline auto convertInto( std::string const &source, bool &target ) -...
      function convertInto (line 678) | inline auto convertInto( std::string const &source, CLARA_CONFIG_OPT...
      type NonCopyable (line 687) | struct NonCopyable {
        method NonCopyable (line 688) | NonCopyable() = default;
        method NonCopyable (line 689) | NonCopyable( NonCopyable const & ) = delete;
        method NonCopyable (line 690) | NonCopyable( NonCopyable && ) = delete;
        method NonCopyable (line 691) | NonCopyable &operator=( NonCopyable const & ) = delete;
        method NonCopyable (line 692) | NonCopyable &operator=( NonCopyable && ) = delete;
      type BoundRef (line 695) | struct BoundRef : NonCopyable {
        method isContainer (line 697) | virtual auto isContainer() const -> bool { return false; }
        method isFlag (line 698) | virtual auto isFlag() const -> bool { return false; }
      type BoundValueRefBase (line 700) | struct BoundValueRefBase : BoundRef {
      type BoundFlagRefBase (line 703) | struct BoundFlagRefBase : BoundRef {
        method isFlag (line 705) | virtual auto isFlag() const -> bool { return true; }
      type BoundValueRef (line 709) | struct BoundValueRef : BoundValueRefBase {
        method BoundValueRef (line 712) | explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
        method setValue (line 714) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundValueRef<std::vector<T>> (line 720) | struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
        method BoundValueRef (line 723) | explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
        method isContainer (line 725) | auto isContainer() const -> bool override { return true; }
        method setValue (line 727) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundFlagRef (line 736) | struct BoundFlagRef : BoundFlagRefBase {
        method BoundFlagRef (line 739) | explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
        method setFlag (line 741) | auto setFlag( bool flag ) -> ParserResult override {
      type LambdaInvoker (line 748) | struct LambdaInvoker {
        method invoke (line 752) | static auto invoke( L const &lambda, ArgType const &arg ) -> Parse...
      type LambdaInvoker<void> (line 758) | struct LambdaInvoker<void> {
        method invoke (line 760) | static auto invoke( L const &lambda, ArgType const &arg ) -> Parse...
      function invokeLambda (line 767) | inline auto invokeLambda( L const &lambda, std::string const &arg ) ...
      type BoundLambda (line 777) | struct BoundLambda : BoundValueRefBase {
        method BoundLambda (line 781) | explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
        method setValue (line 783) | auto setValue( std::string const &arg ) -> ParserResult override {
      type BoundFlagLambda (line 789) | struct BoundFlagLambda : BoundFlagRefBase {
        method BoundFlagLambda (line 795) | explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
        method setFlag (line 797) | auto setFlag( bool flag ) -> ParserResult override {
      type Optionality (line 802) | enum class Optionality { Optional, Required }
      type Parser (line 804) | struct Parser
        method getHelpColumns (line 1111) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method writeToStream (line 1120) | void writeToStream( std::ostream &os ) const {
        method validate (line 1166) | auto validate() const -> Result override {
        method parse (line 1182) | auto parse( std::string const& exeName, TokenStream const &tokens ...
      class ParserBase (line 806) | class ParserBase {
        method validate (line 809) | virtual auto validate() const -> Result { return Result::ok(); }
        method cardinality (line 811) | virtual auto cardinality() const -> size_t { return 1; }
        method parse (line 813) | auto parse( Args const &args ) const -> InternalParseResult {
      class ComposableParserImpl (line 819) | class ComposableParserImpl : public ParserBase {
      class ParserRefImpl (line 830) | class ParserRefImpl : public ComposableParserImpl<DerivedT> {
        method ParserRefImpl (line 837) | explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m...
        method ParserRefImpl (line 841) | ParserRefImpl( T &ref, std::string const &hint )
        method ParserRefImpl (line 847) | ParserRefImpl( LambdaT const &ref, std::string const &hint )
        method optional (line 857) | auto optional() -> DerivedT & {
        method required (line 862) | auto required() -> DerivedT & {
        method isOptional (line 867) | auto isOptional() const -> bool {
        method cardinality (line 871) | auto cardinality() const -> size_t override {
        method hint (line 878) | auto hint() const -> std::string { return m_hint; }
      class ExeName (line 881) | class ExeName : public ComposableParserImpl<ExeName> {
        method makeRef (line 886) | static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<Boun...
        method ExeName (line 891) | ExeName() : m_name( std::make_shared<std::string>( "<executable>" ...
        method ExeName (line 893) | explicit ExeName( std::string &ref ) : ExeName() {
        method ExeName (line 898) | explicit ExeName( LambdaT const& lambda ) : ExeName() {
        method parse (line 903) | auto parse( std::string const&, TokenStream const &tokens ) const ...
        method name (line 907) | auto name() const -> std::string { return *m_name; }
        method set (line 908) | auto set( std::string const& newName ) -> ParserResult {
      class Arg (line 923) | class Arg : public ParserRefImpl<Arg> {
        method parse (line 927) | auto parse( std::string const &, TokenStream const &tokens ) const...
      function normaliseOpt (line 948) | inline auto normaliseOpt( std::string const &optName ) -> std::string {
      class Opt (line 957) | class Opt : public ParserRefImpl<Opt> {
        method Opt (line 963) | explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shar...
        method Opt (line 965) | explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundF...
        method Opt (line 968) | Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl...
        method Opt (line 971) | Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ...
        method getHelpColumns (line 978) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method isMatch (line 993) | auto isMatch( std::string const &optToken ) const -> bool {
        method parse (line 1004) | auto parse( std::string const&, TokenStream const &tokens ) const ...
        method validate (line 1040) | auto validate() const -> Result override {
      type Help (line 1058) | struct Help : Opt {
        method Help (line 1059) | Help( bool &showHelpFlag )
      type Parser (line 1073) | struct Parser : ParserBase {
        method getHelpColumns (line 1111) | auto getHelpColumns() const -> std::vector<HelpColumns> {
        method writeToStream (line 1120) | void writeToStream( std::ostream &os ) const {
        method validate (line 1166) | auto validate() const -> Result override {
        method parse (line 1182) | auto parse( std::string const& exeName, TokenStream const &tokens ...
  type UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> (line 391) | struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {

FILE: src/ClaraTests.cpp
  type Catch (line 9) | namespace Catch {
    type StringMaker<clara::detail::InternalParseResult> (line 11) | struct StringMaker<clara::detail::InternalParseResult> {
      method convert (line 12) | static std::string convert( clara::detail::InternalParseResult const...
  function toString (line 27) | std::string toString( Opt const& opt ) {
  function toString (line 32) | std::string toString( Parser const& p ) {
  type Config (line 87) | struct Config {
  type TestOpt (line 149) | struct TestOpt {
    method makeCli (line 159) | auto makeCli() -> Parser {
  type TestOpt2 (line 186) | struct TestOpt2 {

FILE: third_party/TextFlow.hpp
  type TextFlow (line 23) | namespace TextFlow {
    function isWhitespace (line 25) | inline auto isWhitespace( char c ) -> bool {
    function isBreakableBefore (line 29) | inline auto isBreakableBefore( char c ) -> bool {
    function isBreakableAfter (line 33) | inline auto isBreakableAfter( char c ) -> bool {
    class Columns (line 38) | class Columns
      class iterator (line 221) | class iterator {
        type EndTag (line 223) | struct EndTag {}
        method iterator (line 229) | iterator( Columns const& columns, EndTag )
        method iterator (line 246) | explicit iterator( Columns const& columns )
      method begin (line 296) | auto begin() const -> iterator { return iterator( *this ); }
      method end (line 297) | auto end() const -> iterator { return { *this, iterator::EndTag() }; }
      method friend (line 309) | inline friend std::ostream& operator << ( std::ostream& os, Columns ...
      method toString (line 322) | auto toString() const -> std::string {
    class Column (line 40) | class Column {
      class iterator (line 47) | class iterator {
        method iterator (line 58) | iterator( Column const& column, size_t stringIndex )
        method line (line 63) | auto line() const -> std::string const& { return m_column.m_string...
        method isBoundary (line 65) | auto isBoundary( size_t at ) const -> bool {
        method calcLength (line 75) | void calcLength() {
        method indent (line 103) | auto indent() const -> size_t {
        method addIndentAndSuffix (line 108) | auto addIndentAndSuffix(std::string const &plain) const -> std::st...
        method iterator (line 119) | explicit iterator( Column const& column ) : m_column( column ) {
      method Column (line 167) | explicit Column( std::string const& text ) { m_strings.push_back( te...
      method width (line 169) | auto width( size_t newWidth ) -> Column& {
      method indent (line 174) | auto indent( size_t newIndent ) -> Column& {
      method initialIndent (line 178) | auto initialIndent( size_t newIndent ) -> Column& {
      method width (line 183) | auto width() const -> size_t { return m_width; }
      method begin (line 184) | auto begin() const -> iterator { return iterator( *this ); }
      method end (line 185) | auto end() const -> iterator { return { *this, m_strings.size() }; }
      method friend (line 187) | inline friend std::ostream& operator << ( std::ostream& os, Column c...
      method toString (line 201) | auto toString() const -> std::string {
    class Spacer (line 208) | class Spacer : public Column {
      method Spacer (line 211) | explicit Spacer( size_t spaceWidth ) : Column( "" ) {
    class Columns (line 216) | class Columns {
      class iterator (line 221) | class iterator {
        type EndTag (line 223) | struct EndTag {}
        method iterator (line 229) | iterator( Columns const& columns, EndTag )
        method iterator (line 246) | explicit iterator( Columns const& columns )
      method begin (line 296) | auto begin() const -> iterator { return iterator( *this ); }
      method end (line 297) | auto end() const -> iterator { return { *this, iterator::EndTag() }; }
      method friend (line 309) | inline friend std::ostream& operator << ( std::ostream& os, Columns ...
      method toString (line 322) | auto toString() const -> std::string {

FILE: third_party/catch.hpp
  type Catch (line 86) | namespace Catch {
    type CaseSensitive (line 223) | struct CaseSensitive { enum Choice {
      type Choice (line 223) | enum Choice {
    class NonCopyable (line 228) | class NonCopyable {
      method NonCopyable (line 229) | NonCopyable( NonCopyable const& )              = delete;
      method NonCopyable (line 230) | NonCopyable( NonCopyable && )                  = delete;
      method NonCopyable (line 231) | NonCopyable& operator = ( NonCopyable const& ) = delete;
      method NonCopyable (line 232) | NonCopyable& operator = ( NonCopyable && )     = delete;
    type SourceLineInfo (line 239) | struct SourceLineInfo {
      method SourceLineInfo (line 241) | SourceLineInfo() = delete;
      method SourceLineInfo (line 242) | SourceLineInfo( char const* _file, std::size_t _line ) noexcept
      method SourceLineInfo (line 247) | SourceLineInfo( SourceLineInfo const& other )        = default;
      method SourceLineInfo (line 248) | SourceLineInfo( SourceLineInfo && )                  = default;
      method SourceLineInfo (line 249) | SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
      method SourceLineInfo (line 250) | SourceLineInfo& operator = ( SourceLineInfo && )     = default;
    type StreamEndStop (line 266) | struct StreamEndStop {
    function T (line 270) | T const& operator + ( T const& value, StreamEndStop ) {
    type RegistrarForTagAliases (line 281) | struct RegistrarForTagAliases {
    class TestSpec (line 302) | class TestSpec
      type Pattern (line 2984) | struct Pattern {
      class NamePattern (line 2990) | class NamePattern : public Pattern {
      class TagPattern (line 2999) | class TagPattern : public Pattern {
      class ExcludedPattern (line 3008) | class ExcludedPattern : public Pattern {
      type Filter (line 3017) | struct Filter {
    type ITestInvoker (line 304) | struct ITestInvoker {
    class TestCase (line 311) | class TestCase
    type IConfig (line 312) | struct IConfig
    type ITestCaseRegistry (line 314) | struct ITestCaseRegistry {
    class StringData (line 335) | class StringData
    class StringRef (line 344) | class StringRef {
      method StringRef (line 361) | StringRef() noexcept
      method StringRef (line 365) | StringRef( StringRef const& other ) noexcept
      method StringRef (line 370) | StringRef( StringRef&& other ) noexcept
      method StringRef (line 380) | StringRef( char const* rawChars, size_type size ) noexcept
      method StringRef (line 385) | StringRef( std::string const& stdString ) noexcept
      method empty (line 413) | auto empty() const noexcept -> bool {
      method size (line 416) | auto size() const noexcept -> size_type {
    class TestInvokerAsMethod (line 448) | class TestInvokerAsMethod : public ITestInvoker {
      method TestInvokerAsMethod (line 451) | TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAs...
      method invoke (line 453) | void invoke() const override {
    function makeTestInvoker (line 462) | auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInv...
    type NameAndTags (line 466) | struct NameAndTags {
    type AutoReg (line 472) | struct AutoReg : NonCopyable {
    type AssertionInfo (line 583) | struct AssertionInfo
    class StringRef (line 618) | class StringRef
      method StringRef (line 361) | StringRef() noexcept
      method StringRef (line 365) | StringRef( StringRef const& other ) noexcept
      method StringRef (line 370) | StringRef( StringRef&& other ) noexcept
      method StringRef (line 380) | StringRef( char const* rawChars, size_type size ) noexcept
      method StringRef (line 385) | StringRef( std::string const& stdString ) noexcept
      method empty (line 413) | auto empty() const noexcept -> bool {
      method size (line 416) | auto size() const noexcept -> size_type {
    type IStream (line 620) | struct IStream {
    class ReusableStringStream (line 627) | class ReusableStringStream {
      method get (line 641) | auto get() -> std::ostream& { return *m_oss; }
    type Detail (line 708) | namespace Detail {
      function rawMemoryToString (line 715) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 720) | class IsStreamInsertable {
      function convertUnstreamable (line 736) | typename std::enable_if<!std::is_enum<T>::value, std::string>::type ...
      function convertUnstreamable (line 740) | typename std::enable_if<std::is_enum<T>::value, std::string>::type c...
      function stringify (line 771) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 776) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 923) | std::string rangeToString(InputIterator first, InputIterator last) {
      function stringify (line 953) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1001) | struct TupleElementPrinter {
        method print (line 1002) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1013) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1014) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 1983) | class Approx {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      function Approx (line 4505) | Approx Approx::custom() {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      type Endianness (line 10403) | struct Endianness {
        type Arch (line 10404) | enum Arch { Big, Little }
        method Arch (line 10406) | static Arch which() {
      function rawMemoryToString (line 10418) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker (line 748) | struct StringMaker {
      method convert (line 750) | static
      method convert (line 759) | static
    type Detail (line 766) | namespace Detail {
      function rawMemoryToString (line 715) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 720) | class IsStreamInsertable {
      function convertUnstreamable (line 736) | typename std::enable_if<!std::is_enum<T>::value, std::string>::type ...
      function convertUnstreamable (line 740) | typename std::enable_if<std::is_enum<T>::value, std::string>::type c...
      function stringify (line 771) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 776) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 923) | std::string rangeToString(InputIterator first, InputIterator last) {
      function stringify (line 953) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1001) | struct TupleElementPrinter {
        method print (line 1002) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1013) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1014) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 1983) | class Approx {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      function Approx (line 4505) | Approx Approx::custom() {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      type Endianness (line 10403) | struct Endianness {
        type Arch (line 10404) | enum Arch { Big, Little }
        method Arch (line 10406) | static Arch which() {
      function rawMemoryToString (line 10418) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker<std::string> (line 785) | struct StringMaker<std::string> {
    type StringMaker<std::wstring> (line 789) | struct StringMaker<std::wstring> {
    type StringMaker<char const *> (line 794) | struct StringMaker<char const *> {
    type StringMaker<char *> (line 798) | struct StringMaker<char *> {
    type StringMaker<wchar_t const *> (line 802) | struct StringMaker<wchar_t const *> {
    type StringMaker<wchar_t *> (line 806) | struct StringMaker<wchar_t *> {
    type is_string_array (line 811) | struct is_string_array : std::false_type {}
    type is_string_array<char[N]> (line 814) | struct is_string_array<char[N]> : std::true_type {}
    type is_string_array<signed char[N]> (line 817) | struct is_string_array<signed char[N]> : std::true_type {}
    type is_string_array<unsigned char[N]> (line 820) | struct is_string_array<unsigned char[N]> : std::true_type {}
    type StringMaker<char[SZ]> (line 823) | struct StringMaker<char[SZ]> {
      method convert (line 824) | static std::string convert(const char* str) {
    type StringMaker<signed char[SZ]> (line 829) | struct StringMaker<signed char[SZ]> {
      method convert (line 830) | static std::string convert(const char* str) {
    type StringMaker<unsigned char[SZ]> (line 835) | struct StringMaker<unsigned char[SZ]> {
      method convert (line 836) | static std::string convert(const char* str) {
    type StringMaker<int> (line 842) | struct StringMaker<int> {
    type StringMaker<long> (line 846) | struct StringMaker<long> {
    type StringMaker<long long> (line 850) | struct StringMaker<long long> {
    type StringMaker<unsigned int> (line 854) | struct StringMaker<unsigned int> {
    type StringMaker<unsigned long> (line 858) | struct StringMaker<unsigned long> {
    type StringMaker<unsigned long long> (line 862) | struct StringMaker<unsigned long long> {
    type StringMaker<bool> (line 867) | struct StringMaker<bool> {
    type StringMaker<char> (line 872) | struct StringMaker<char> {
    type StringMaker<signed char> (line 876) | struct StringMaker<signed char> {
    type StringMaker<unsigned char> (line 880) | struct StringMaker<unsigned char> {
    type StringMaker<std::nullptr_t> (line 885) | struct StringMaker<std::nullptr_t> {
    type StringMaker<float> (line 890) | struct StringMaker<float> {
    type StringMaker<double> (line 894) | struct StringMaker<double> {
    type StringMaker<T*> (line 899) | struct StringMaker<T*> {
      method convert (line 901) | static std::string convert(U* p) {
    type StringMaker<R C::*> (line 911) | struct StringMaker<R C::*> {
      method convert (line 912) | static std::string convert(R C::* p) {
    type Detail (line 921) | namespace Detail {
      function rawMemoryToString (line 715) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 720) | class IsStreamInsertable {
      function convertUnstreamable (line 736) | typename std::enable_if<!std::is_enum<T>::value, std::string>::type ...
      function convertUnstreamable (line 740) | typename std::enable_if<std::is_enum<T>::value, std::string>::type c...
      function stringify (line 771) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 776) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 923) | std::string rangeToString(InputIterator first, InputIterator last) {
      function stringify (line 953) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1001) | struct TupleElementPrinter {
        method print (line 1002) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1013) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1014) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 1983) | class Approx {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      function Approx (line 4505) | Approx Approx::custom() {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      type Endianness (line 10403) | struct Endianness {
        type Arch (line 10404) | enum Arch { Big, Little }
        method Arch (line 10406) | static Arch which() {
      function rawMemoryToString (line 10418) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker<NSString*> (line 938) | struct StringMaker<NSString*> {
      method convert (line 939) | static std::string convert(NSString * nsstring) {
    type StringMaker<NSObject*> (line 946) | struct StringMaker<NSObject*> {
      method convert (line 947) | static std::string convert(NSObject* nsObject) {
    type Detail (line 952) | namespace Detail {
      function rawMemoryToString (line 715) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 720) | class IsStreamInsertable {
      function convertUnstreamable (line 736) | typename std::enable_if<!std::is_enum<T>::value, std::string>::type ...
      function convertUnstreamable (line 740) | typename std::enable_if<std::is_enum<T>::value, std::string>::type c...
      function stringify (line 771) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 776) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 923) | std::string rangeToString(InputIterator first, InputIterator last) {
      function stringify (line 953) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1001) | struct TupleElementPrinter {
        method print (line 1002) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1013) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1014) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 1983) | class Approx {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      function Approx (line 4505) | Approx Approx::custom() {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      type Endianness (line 10403) | struct Endianness {
        type Arch (line 10404) | enum Arch { Big, Little }
        method Arch (line 10406) | static Arch which() {
      function rawMemoryToString (line 10418) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker<std::pair<T1, T2> > (line 977) | struct StringMaker<std::pair<T1, T2> > {
      method convert (line 978) | static std::string convert(const std::pair<T1, T2>& pair) {
    type Detail (line 995) | namespace Detail {
      function rawMemoryToString (line 715) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 720) | class IsStreamInsertable {
      function convertUnstreamable (line 736) | typename std::enable_if<!std::is_enum<T>::value, std::string>::type ...
      function convertUnstreamable (line 740) | typename std::enable_if<std::is_enum<T>::value, std::string>::type c...
      function stringify (line 771) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 776) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 923) | std::string rangeToString(InputIterator first, InputIterator last) {
      function stringify (line 953) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1001) | struct TupleElementPrinter {
        method print (line 1002) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1013) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1014) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 1983) | class Approx {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      function Approx (line 4505) | Approx Approx::custom() {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      type Endianness (line 10403) | struct Endianness {
        type Arch (line 10404) | enum Arch { Big, Little }
        method Arch (line 10406) | static Arch which() {
      function rawMemoryToString (line 10418) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type not_this_one (line 1033) | struct not_this_one {}
    type is_range (line 1043) | struct is_range {
    function rangeToString (line 1050) | std::string rangeToString( Range const& range ) {
    function rangeToString (line 1056) | std::string rangeToString( std::vector<bool, Allocator> const& v ) {
    type StringMaker<R, typename std::enable_if<is_range<R>::value && !is_string_array<R>::value>::type> (line 1072) | struct StringMaker<R, typename std::enable_if<is_range<R>::value && !i...
      method convert (line 1073) | static std::string convert( R const& range ) {
    type ratio_string (line 1089) | struct ratio_string {
    type ratio_string<std::atto> (line 1101) | struct ratio_string<std::atto> {
    type ratio_string<std::femto> (line 1105) | struct ratio_string<std::femto> {
    type ratio_string<std::pico> (line 1109) | struct ratio_string<std::pico> {
    type ratio_string<std::nano> (line 1113) | struct ratio_string<std::nano> {
    type ratio_string<std::micro> (line 1117) | struct ratio_string<std::micro> {
    type ratio_string<std::milli> (line 1121) | struct ratio_string<std::milli> {
    type StringMaker<std::chrono::duration<Value, Ratio>> (line 1128) | struct StringMaker<std::chrono::duration<Value, Ratio>> {
      method convert (line 1129) | static std::string convert(std::chrono::duration<Value, Ratio> const...
    type StringMaker<std::chrono::duration<Value, std::ratio<1>>> (line 1136) | struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
      method convert (line 1137) | static std::string convert(std::chrono::duration<Value, std::ratio<1...
    type StringMaker<std::chrono::duration<Value, std::ratio<60>>> (line 1144) | struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
      method convert (line 1145) | static std::string convert(std::chrono::duration<Value, std::ratio<6...
    type StringMaker<std::chrono::duration<Value, std::ratio<3600>>> (line 1152) | struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
      method convert (line 1153) | static std::string convert(std::chrono::duration<Value, std::ratio<3...
    type StringMaker<std::chrono::time_point<Clock, Duration>> (line 1164) | struct StringMaker<std::chrono::time_point<Clock, Duration>> {
      method convert (line 1165) | static std::string convert(std::chrono::time_point<Clock, Duration> ...
    type StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> (line 1171) | struct StringMaker<std::chrono::time_point<std::chrono::system_clock, ...
      method convert (line 1172) | static std::string convert(std::chrono::time_point<std::chrono::syst...
    type ITransientExpression (line 1214) | struct ITransientExpression {
      method isBinaryExpression (line 1215) | auto isBinaryExpression() const -> bool { return m_isBinaryExpressio...
      method getResult (line 1216) | auto getResult() const -> bool { return m_result; }
      method ITransientExpression (line 1219) | ITransientExpression( bool isBinaryExpression, bool result )
    class BinaryExpr (line 1236) | class BinaryExpr  : public ITransientExpression {
      method streamReconstructedExpression (line 1241) | void streamReconstructedExpression( std::ostream &os ) const override {
      method BinaryExpr (line 1247) | BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
    class UnaryExpr (line 1256) | class UnaryExpr : public ITransientExpression {
      method streamReconstructedExpression (line 1259) | void streamReconstructedExpression( std::ostream &os ) const override {
      method UnaryExpr (line 1264) | explicit UnaryExpr( LhsT lhs )
    function compareEqual (line 1272) | auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return...
    function compareEqual (line 1274) | auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == re...
    function compareEqual (line 1276) | auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == r...
    function compareEqual (line 1278) | auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpr...
    function compareEqual (line 1280) | auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterp...
    function compareNotEqual (line 1283) | auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return l...
    function compareNotEqual (line 1285) | auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs !=...
    function compareNotEqual (line 1287) | auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs !...
    function compareNotEqual (line 1289) | auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinte...
    function compareNotEqual (line 1291) | auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reint...
    class ExprLhs (line 1294) | class ExprLhs {
      method ExprLhs (line 1297) | explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
      method makeUnaryExpr (line 1332) | auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
    function handleExpression (line 1340) | void handleExpression( ExprLhs<T> const& expr ) {
    type Decomposer (line 1344) | struct Decomposer {
    class AssertionResult (line 1368) | class AssertionResult
      method AssertionResult (line 3306) | AssertionResult() = delete;
    type AssertionInfo (line 1369) | struct AssertionInfo
    type SectionInfo (line 1370) | struct SectionInfo
    type SectionEndInfo (line 1371) | struct SectionEndInfo
    type MessageInfo (line 1372) | struct MessageInfo
    type Counts (line 1373) | struct Counts
    type BenchmarkInfo (line 1374) | struct BenchmarkInfo
    type BenchmarkStats (line 1375) | struct BenchmarkStats
    type AssertionReaction (line 1376) | struct AssertionReaction
    type ITransientExpression (line 1378) | struct ITransientExpression
      method isBinaryExpression (line 1215) | auto isBinaryExpression() const -> bool { return m_isBinaryExpressio...
      method getResult (line 1216) | auto getResult() const -> bool { return m_result; }
      method ITransientExpression (line 1219) | ITransientExpression( bool isBinaryExpression, bool result )
    type IResultCapture (line 1380) | struct IResultCapture {
    type TestFailureException (line 1435) | struct TestFailureException{}
    type AssertionResultData (line 1436) | struct AssertionResultData
      method AssertionResultData (line 3292) | AssertionResultData() = delete;
    type IResultCapture (line 1437) | struct IResultCapture
    class RunContext (line 1438) | class RunContext
      method RunContext (line 4733) | RunContext( RunContext const& ) = delete;
      method RunContext (line 4734) | RunContext& operator =( RunContext const& ) = delete;
    class LazyExpression (line 1440) | class LazyExpression {
      method LazyExpression (line 1450) | LazyExpression& operator = ( LazyExpression const& ) = delete;
    type AssertionReaction (line 1457) | struct AssertionReaction {
    class AssertionHandler (line 1462) | class AssertionHandler {
      method handleExpr (line 1481) | void handleExpr( ExprLhs<T> const& expr ) {
    type MessageInfo (line 1512) | struct MessageInfo {
    type MessageStream (line 1529) | struct MessageStream {
      method MessageStream (line 1532) | MessageStream& operator << ( T const& value ) {
    type MessageBuilder (line 1540) | struct MessageBuilder : MessageStream {
      method MessageBuilder (line 1546) | MessageBuilder& operator << ( T const& value ) {
    class ScopedMessage (line 1554) | class ScopedMessage {
    type Counts (line 1707) | struct Counts {
    type Totals (line 1720) | struct Totals {
    type SectionInfo (line 1737) | struct SectionInfo {
    type SectionEndInfo (line 1748) | struct SectionEndInfo {
    class Timer (line 1768) | class Timer {
    class Section (line 1785) | class Section : NonCopyable {
    class BenchmarkLooper (line 1815) | class BenchmarkLooper {
      method BenchmarkLooper (line 1826) | BenchmarkLooper( StringRef name )
      method increment (line 1840) | void increment() {
    class TestCase (line 1863) | class TestCase
    type ITestCaseRegistry (line 1864) | struct ITestCaseRegistry
    type IExceptionTranslatorRegistry (line 1865) | struct IExceptionTranslatorRegistry
    type IExceptionTranslator (line 1866) | struct IExceptionTranslator
    type IReporterRegistry (line 1867) | struct IReporterRegistry
    type IReporterFactory (line 1868) | struct IReporterFactory
    type ITagAliasRegistry (line 1869) | struct ITagAliasRegistry
    class StartupExceptionRegistry (line 1870) | class StartupExceptionRegistry
    type IRegistryHub (line 1874) | struct IRegistryHub {
    type IMutableRegistryHub (line 1886) | struct IMutableRegistryHub {
    type IExceptionTranslator (line 1916) | struct IExceptionTranslator
    type IExceptionTranslator (line 1919) | struct IExceptionTranslator {
    type IExceptionTranslatorRegistry (line 1924) | struct IExceptionTranslatorRegistry {
    class ExceptionTranslatorRegistrar (line 1930) | class ExceptionTranslatorRegistrar {
      class ExceptionTranslator (line 1932) | class ExceptionTranslator : public IExceptionTranslator {
        method ExceptionTranslator (line 1935) | ExceptionTranslator( std::string(*translateFunction)( T& ) )
        method translate (line 1939) | std::string translate( ExceptionTranslators::const_iterator it, Ex...
      method ExceptionTranslatorRegistrar (line 1957) | ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
    type Detail (line 1981) | namespace Detail {
      function rawMemoryToString (line 715) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 720) | class IsStreamInsertable {
      function convertUnstreamable (line 736) | typename std::enable_if<!std::is_enum<T>::value, std::string>::type ...
      function convertUnstreamable (line 740) | typename std::enable_if<std::is_enum<T>::value, std::string>::type c...
      function stringify (line 771) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 776) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 923) | std::string rangeToString(InputIterator first, InputIterator last) {
      function stringify (line 953) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1001) | struct TupleElementPrinter {
        method print (line 1002) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1013) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1014) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 1983) | class Approx {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      function Approx (line 4505) | Approx Approx::custom() {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      type Endianness (line 10403) | struct Endianness {
        type Arch (line 10404) | enum Arch { Big, Little }
        method Arch (line 10406) | static Arch which() {
      function rawMemoryToString (line 10418) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker<Catch::Detail::Approx> (line 2090) | struct StringMaker<Catch::Detail::Approx> {
    type pluralise (line 2114) | struct pluralise {
    type Matchers (line 2134) | namespace Matchers {
      type Impl (line 2135) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 2283) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type StdString (line 2325) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 2394) | namespace Vector {
        type Detail (line 2395) | namespace Detail {
          function count (line 2397) | size_t count(InputIterator first, InputIterator last, T const& i...
          function contains (line 2407) | bool contains(InputIterator first, InputIterator last, T const& ...
        type ContainsElementMatcher (line 2418) | struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
          method ContainsElementMatcher (line 2420) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 2422) | bool match(std::vector<T> const &v) const override {
          method describe (line 2431) | std::string describe() const override {
        type ContainsMatcher (line 2439) | struct ContainsMatcher : MatcherBase<std::vector<T>> {
          method ContainsMatcher (line 2441) | ContainsMatcher(std::vector<T> const &comparator) : m_comparator...
          method match (line 2443) | bool match(std::vector<T> const &v) const override {
          method describe (line 2461) | std::string describe() const override {
        type EqualsMatcher (line 2469) | struct EqualsMatcher : MatcherBase<std::vector<T>> {
          method EqualsMatcher (line 2471) | EqualsMatcher(std::vector<T> const &comparator) : m_comparator( ...
          method match (line 2473) | bool match(std::vector<T> const &v) const override {
          method describe (line 2485) | std::string describe() const override {
        type UnorderedEqualsMatcher (line 2492) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
          method UnorderedEqualsMatcher (line 2493) | UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(...
          method match (line 2494) | bool match(std::vector<T> const& vec) const override {
          method describe (line 2524) | std::string describe() const override {
      function Contains (line 2537) | Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparato...
      function VectorContains (line 2542) | Vector::ContainsElementMatcher<T> VectorContains( T const& comparato...
      function Equals (line 2547) | Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
      function UnorderedEquals (line 2552) | Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> con...
      type Impl (line 7703) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 7730) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type Floating (line 7791) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 7833) | Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
      function WithinULP (line 7837) | Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
      function WithinAbs (line 7841) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      type StdString (line 7856) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 7931) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 7934) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 7937) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 7940) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 7944) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 2281) | namespace Matchers {
      type Impl (line 2135) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 2283) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type StdString (line 2325) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 2394) | namespace Vector {
        type Detail (line 2395) | namespace Detail {
          function count (line 2397) | size_t count(InputIterator first, InputIterator last, T const& i...
          function contains (line 2407) | bool contains(InputIterator first, InputIterator last, T const& ...
        type ContainsElementMatcher (line 2418) | struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
          method ContainsElementMatcher (line 2420) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 2422) | bool match(std::vector<T> const &v) const override {
          method describe (line 2431) | std::string describe() const override {
        type ContainsMatcher (line 2439) | struct ContainsMatcher : MatcherBase<std::vector<T>> {
          method ContainsMatcher (line 2441) | ContainsMatcher(std::vector<T> const &comparator) : m_comparator...
          method match (line 2443) | bool match(std::vector<T> const &v) const override {
          method describe (line 2461) | std::string describe() const override {
        type EqualsMatcher (line 2469) | struct EqualsMatcher : MatcherBase<std::vector<T>> {
          method EqualsMatcher (line 2471) | EqualsMatcher(std::vector<T> const &comparator) : m_comparator( ...
          method match (line 2473) | bool match(std::vector<T> const &v) const override {
          method describe (line 2485) | std::string describe() const override {
        type UnorderedEqualsMatcher (line 2492) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
          method UnorderedEqualsMatcher (line 2493) | UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(...
          method match (line 2494) | bool match(std::vector<T> const& vec) const override {
          method describe (line 2524) | std::string describe() const override {
      function Contains (line 2537) | Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparato...
      function VectorContains (line 2542) | Vector::ContainsElementMatcher<T> VectorContains( T const& comparato...
      function Equals (line 2547) | Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
      function UnorderedEquals (line 2552) | Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> con...
      type Impl (line 7703) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 7730) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type Floating (line 7791) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 7833) | Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
      function WithinULP (line 7837) | Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
      function WithinAbs (line 7841) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      type StdString (line 7856) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 7931) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 7934) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 7937) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 7940) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 7944) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 2323) | namespace Matchers {
      type Impl (line 2135) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 2283) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type StdString (line 2325) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 2394) | namespace Vector {
        type Detail (line 2395) | namespace Detail {
          function count (line 2397) | size_t count(InputIterator first, InputIterator last, T const& i...
          function contains (line 2407) | bool contains(InputIterator first, InputIterator last, T const& ...
        type ContainsElementMatcher (line 2418) | struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
          method ContainsElementMatcher (line 2420) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 2422) | bool match(std::vector<T> const &v) const override {
          method describe (line 2431) | std::string describe() const override {
        type ContainsMatcher (line 2439) | struct ContainsMatcher : MatcherBase<std::vector<T>> {
          method ContainsMatcher (line 2441) | ContainsMatcher(std::vector<T> const &comparator) : m_comparator...
          method match (line 2443) | bool match(std::vector<T> const &v) const override {
          method describe (line 2461) | std::string describe() const override {
        type EqualsMatcher (line 2469) | struct EqualsMatcher : MatcherBase<std::vector<T>> {
          method EqualsMatcher (line 2471) | EqualsMatcher(std::vector<T> const &comparator) : m_comparator( ...
          method match (line 2473) | bool match(std::vector<T> const &v) const override {
          method describe (line 2485) | std::string describe() const override {
        type UnorderedEqualsMatcher (line 2492) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
          method UnorderedEqualsMatcher (line 2493) | UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(...
          method match (line 2494) | bool match(std::vector<T> const& vec) const override {
          method describe (line 2524) | std::string describe() const override {
      function Contains (line 2537) | Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparato...
      function VectorContains (line 2542) | Vector::ContainsElementMatcher<T> VectorContains( T const& comparato...
      function Equals (line 2547) | Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
      function UnorderedEquals (line 2552) | Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> con...
      type Impl (line 7703) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 7730) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type Floating (line 7791) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 7833) | Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
      function WithinULP (line 7837) | Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
      function WithinAbs (line 7841) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      type StdString (line 7856) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 7931) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 7934) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 7937) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 7940) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 7944) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 2392) | namespace Matchers {
      type Impl (line 2135) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 2283) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type StdString (line 2325) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 2394) | namespace Vector {
        type Detail (line 2395) | namespace Detail {
          function count (line 2397) | size_t count(InputIterator first, InputIterator last, T const& i...
          function contains (line 2407) | bool contains(InputIterator first, InputIterator last, T const& ...
        type ContainsElementMatcher (line 2418) | struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
          method ContainsElementMatcher (line 2420) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 2422) | bool match(std::vector<T> const &v) const override {
          method describe (line 2431) | std::string describe() const override {
        type ContainsMatcher (line 2439) | struct ContainsMatcher : MatcherBase<std::vector<T>> {
          method ContainsMatcher (line 2441) | ContainsMatcher(std::vector<T> const &comparator) : m_comparator...
          method match (line 2443) | bool match(std::vector<T> const &v) const override {
          method describe (line 2461) | std::string describe() const override {
        type EqualsMatcher (line 2469) | struct EqualsMatcher : MatcherBase<std::vector<T>> {
          method EqualsMatcher (line 2471) | EqualsMatcher(std::vector<T> const &comparator) : m_comparator( ...
          method match (line 2473) | bool match(std::vector<T> const &v) const override {
          method describe (line 2485) | std::string describe() const override {
        type UnorderedEqualsMatcher (line 2492) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
          method UnorderedEqualsMatcher (line 2493) | UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(...
          method match (line 2494) | bool match(std::vector<T> const& vec) const override {
          method describe (line 2524) | std::string describe() const override {
      function Contains (line 2537) | Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparato...
      function VectorContains (line 2542) | Vector::ContainsElementMatcher<T> VectorContains( T const& comparato...
      function Equals (line 2547) | Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
      function UnorderedEquals (line 2552) | Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> con...
      type Impl (line 7703) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 7730) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type Floating (line 7791) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 7833) | Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
      function WithinULP (line 7837) | Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
      function WithinAbs (line 7841) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      type StdString (line 7856) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 7931) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 7934) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 7937) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 7940) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 7944) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    class MatchExpr (line 2563) | class MatchExpr : public ITransientExpression {
      method MatchExpr (line 2568) | MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef match...
      method streamReconstructedExpression (line 2575) | void streamReconstructedExpression( std::ostream &os ) const override {
    function makeMatchExpr (line 2590) | auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRe...
    type ITestInvoker (line 2644) | struct ITestInvoker
    type TestCaseInfo (line 2646) | struct TestCaseInfo {
      type SpecialProperties (line 2647) | enum SpecialProperties{
    class TestCase (line 2681) | class TestCase : public TestCaseInfo {
    type IRunner (line 2715) | struct IRunner {
    class WildcardPattern (line 2954) | class WildcardPattern {
      type WildcardPosition (line 2955) | enum WildcardPosition {
    class TestSpec (line 2983) | class TestSpec {
      type Pattern (line 2984) | struct Pattern {
      class NamePattern (line 2990) | class NamePattern : public Pattern {
      class TagPattern (line 2999) | class TagPattern : public Pattern {
      class ExcludedPattern (line 3008) | class ExcludedPattern : public Pattern {
      type Filter (line 3017) | struct Filter {
    type TagAlias (line 3045) | struct TagAlias
    type ITagAliasRegistry (line 3047) | struct ITagAliasRegistry {
    class TestSpecParser (line 3061) | class TestSpecParser {
      type Mode (line 3062) | enum Mode{ None, Name, QuotedName, Tag, EscapedName }
      method addPattern (line 3085) | void addPattern() {
    type Verbosity (line 3124) | enum class Verbosity {
    type WarnAbout (line 3130) | struct WarnAbout { enum What {
      type What (line 3130) | enum What {
    type ShowDurations (line 3135) | struct ShowDurations { enum OrNot {
      type OrNot (line 3135) | enum OrNot {
    type RunTests (line 3140) | struct RunTests { enum InWhatOrder {
      type InWhatOrder (line 3140) | enum InWhatOrder {
    type UseColour (line 3145) | struct UseColour { enum YesOrNo {
      type YesOrNo (line 3145) | enum YesOrNo {
    type WaitForKeypress (line 3150) | struct WaitForKeypress { enum When {
      type When (line 3150) | enum When {
    class TestSpec (line 3157) | class TestSpec
      type Pattern (line 2984) | struct Pattern {
      class NamePattern (line 2990) | class NamePattern : public Pattern {
      class TagPattern (line 2999) | class TagPattern : public Pattern {
      class ExcludedPattern (line 3008) | class ExcludedPattern : public Pattern {
      type Filter (line 3017) | struct Filter {
    type IConfig (line 3159) | struct IConfig : NonCopyable {
    type IStream (line 3197) | struct IStream
    type ConfigData (line 3199) | struct ConfigData {
    class Config (line 3233) | class Config : public IConfig {
      method Config (line 3236) | Config() = default;
    type AssertionResultData (line 3290) | struct AssertionResultData
      method AssertionResultData (line 3292) | AssertionResultData() = delete;
    class AssertionResult (line 3304) | class AssertionResult {
      method AssertionResult (line 3306) | AssertionResult() = delete;
    class Option (line 3336) | class Option {
      method Option (line 3338) | Option() : nullableValue( nullptr ) {}
      method Option (line 3339) | Option( T const& _value )
      method Option (line 3342) | Option( Option const& _other )
      method Option (line 3350) | Option& operator= ( Option const& _other ) {
      method Option (line 3358) | Option& operator = ( T const& _value ) {
      method reset (line 3364) | void reset() {
      method T (line 3370) | T& operator*() { return *nullableValue; }
      method T (line 3371) | T const& operator*() const { return *nullableValue; }
      method T (line 3372) | T* operator->() { return nullableValue; }
      method T (line 3373) | const T* operator->() const { return nullableValue; }
      method T (line 3375) | T valueOr( T const& defaultValue ) const {
      method some (line 3379) | bool some() const { return nullableValue != nullptr; }
      method none (line 3380) | bool none() const { return nullableValue == nullptr; }
    type ReporterConfig (line 3403) | struct ReporterConfig {
    type ReporterPreferences (line 3416) | struct ReporterPreferences {
    type LazyStat (line 3421) | struct LazyStat : Option<T> {
      method LazyStat (line 3422) | LazyStat& operator=( T const& _value ) {
      method reset (line 3427) | void reset() {
    type TestRunInfo (line 3434) | struct TestRunInfo {
    type GroupInfo (line 3438) | struct GroupInfo {
    type AssertionStats (line 3448) | struct AssertionStats {
      method AssertionStats (line 3453) | AssertionStats( AssertionStats const& )              = default;
      method AssertionStats (line 3454) | AssertionStats( AssertionStats && )                  = default;
      method AssertionStats (line 3455) | AssertionStats& operator = ( AssertionStats const& ) = default;
      method AssertionStats (line 3456) | AssertionStats& operator = ( AssertionStats && )     = default;
    type SectionStats (line 3464) | struct SectionStats {
      method SectionStats (line 3469) | SectionStats( SectionStats const& )              = default;
      method SectionStats (line 3470) | SectionStats( SectionStats && )                  = default;
      method SectionStats (line 3471) | SectionStats& operator = ( SectionStats const& ) = default;
      method SectionStats (line 3472) | SectionStats& operator = ( SectionStats && )     = default;
    type TestCaseStats (line 3481) | struct TestCaseStats {
      method TestCaseStats (line 3488) | TestCaseStats( TestCaseStats const& )              = default;
      method TestCaseStats (line 3489) | TestCaseStats( TestCaseStats && )                  = default;
      method TestCaseStats (line 3490) | TestCaseStats& operator = ( TestCaseStats const& ) = default;
      method TestCaseStats (line 3491) | TestCaseStats& operator = ( TestCaseStats && )     = default;
    type TestGroupStats (line 3501) | struct TestGroupStats {
      method TestGroupStats (line 3507) | TestGroupStats( TestGroupStats const& )              = default;
      method TestGroupStats (line 3508) | TestGroupStats( TestGroupStats && )                  = default;
      method TestGroupStats (line 3509) | TestGroupStats& operator = ( TestGroupStats const& ) = default;
      method TestGroupStats (line 3510) | TestGroupStats& operator = ( TestGroupStats && )     = default;
    type TestRunStats (line 3518) | struct TestRunStats {
      method TestRunStats (line 3523) | TestRunStats( TestRunStats const& )              = default;
      method TestRunStats (line 3524) | TestRunStats( TestRunStats && )                  = default;
      method TestRunStats (line 3525) | TestRunStats& operator = ( TestRunStats const& ) = default;
      method TestRunStats (line 3526) | TestRunStats& operator = ( TestRunStats && )     = default;
    type BenchmarkInfo (line 3534) | struct BenchmarkInfo {
    type BenchmarkStats (line 3537) | struct BenchmarkStats {
    type IStreamingReporter (line 3543) | struct IStreamingReporter {
      method benchmarkStarting (line 3561) | virtual void benchmarkStarting( BenchmarkInfo const& ) {}
      method benchmarkEnded (line 3569) | virtual void benchmarkEnded( BenchmarkStats const& ) {}
    type IReporterFactory (line 3585) | struct IReporterFactory {
    type IReporterRegistry (line 3592) | struct IReporterRegistry {
    type StreamingReporterBase (line 3622) | struct StreamingReporterBase : IStreamingReporter {
      method StreamingReporterBase (line 3624) | StreamingReporterBase( ReporterConfig const& _config )
      method ReporterPreferences (line 3633) | ReporterPreferences getPreferences() const override {
      method getSupportedVerbosities (line 3637) | static std::set<Verbosity> getSupportedVerbosities() {
      method noMatchingTestCases (line 3643) | void noMatchingTestCases(std::string const&) override {}
      method testRunStarting (line 3645) | void testRunStarting(TestRunInfo const& _testRunInfo) override {
      method testGroupStarting (line 3648) | void testGroupStarting(GroupInfo const& _groupInfo) override {
      method testCaseStarting (line 3652) | void testCaseStarting(TestCaseInfo const& _testInfo) override  {
      method sectionStarting (line 3655) | void sectionStarting(SectionInfo const& _sectionInfo) override {
      method sectionEnded (line 3659) | void sectionEnded(SectionStats const& /* _sectionStats */) override {
      method testCaseEnded (line 3662) | void testCaseEnded(TestCaseStats const& /* _testCaseStats */) overri...
      method testGroupEnded (line 3665) | void testGroupEnded(TestGroupStats const& /* _testGroupStats */) ove...
      method testRunEnded (line 3668) | void testRunEnded(TestRunStats const& /* _testRunStats */) override {
      method skipTest (line 3674) | void skipTest(TestCaseInfo const&) override {
    type CumulativeReporterBase (line 3691) | struct CumulativeReporterBase : IStreamingReporter {
      type Node (line 3693) | struct Node {
        method Node (line 3694) | explicit Node( T const& _value ) : value( _value ) {}
      type SectionNode (line 3701) | struct SectionNode {
        method SectionNode (line 3702) | explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
      type BySectionInfo (line 3721) | struct BySectionInfo {
        method BySectionInfo (line 3722) | BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
        method BySectionInfo (line 3723) | BySectionInfo( BySectionInfo const& other ) : m_other( other.m_oth...
      method CumulativeReporterBase (line 3738) | CumulativeReporterBase( ReporterConfig const& _config )
      method ReporterPreferences (line 3748) | ReporterPreferences getPreferences() const override {
      method getSupportedVerbosities (line 3752) | static std::set<Verbosity> getSupportedVerbosities() {
      method testRunStarting (line 3756) | void testRunStarting( TestRunInfo const& ) override {}
      method testGroupStarting (line 3757) | void testGroupStarting( GroupInfo const& ) override {}
      method testCaseStarting (line 3759) | void testCaseStarting( TestCaseInfo const& ) override {}
      method sectionStarting (line 3761) | void sectionStarting( SectionInfo const& sectionInfo ) override {
      method assertionStarting (line 3786) | void assertionStarting(AssertionInfo const&) override {}
      method assertionEnded (line 3788) | bool assertionEnded(AssertionStats const& assertionStats) override {
      method sectionEnded (line 3800) | void sectionEnded(SectionStats const& sectionStats) override {
      method testCaseEnded (line 3806) | void testCaseEnded(TestCaseStats const& testCaseStats) override {
      method testGroupEnded (line 3817) | void testGroupEnded(TestGroupStats const& testGroupStats) override {
      method testRunEnded (line 3822) | void testRunEnded(TestRunStats const& testRunStats) override {
      method skipTest (line 3830) | void skipTest(TestCaseInfo const&) override {}
    type TestEventListenerBase (line 3857) | struct TestEventListenerBase : StreamingReporterBase<TestEventListener...
    type Colour (line 3871) | struct Colour {
      type Code (line 3872) | enum Code {
    class ReporterRegistrar (line 3931) | class ReporterRegistrar {
      class ReporterFactory (line 3933) | class ReporterFactory : public IReporterFactory {
        method IStreamingReporterPtr (line 3935) | virtual IStreamingReporterPtr create( ReporterConfig const& config...
        method getDescription (line 3939) | virtual std::string getDescription() const override {
      method ReporterRegistrar (line 3946) | explicit ReporterRegistrar( std::string const& name ) {
    class ListenerRegistrar (line 3952) | class ListenerRegistrar {
      class ListenerFactory (line 3954) | class ListenerFactory : public IReporterFactory {
        method IStreamingReporterPtr (line 3956) | virtual IStreamingReporterPtr create( ReporterConfig const& config...
        method getDescription (line 3959) | virtual std::string getDescription() const override {
      method ListenerRegistrar (line 3966) | ListenerRegistrar() {
    type CompactReporter (line 3996) | struct CompactReporter : StreamingReporterBase<CompactReporter> {
    type SummaryColumn (line 4032) | struct SummaryColumn
      method SummaryColumn (line 11765) | SummaryColumn( std::string _label, Colour::Code _colour )
      method SummaryColumn (line 11768) | SummaryColumn addRow( std::size_t count ) {
    class TablePrinter (line 4033) | class TablePrinter
      method TablePrinter (line 11510) | TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
      method columnInfos (line 11514) | auto columnInfos() const -> std::vector<ColumnInfo> const& {
      method open (line 11518) | void open() {
      method close (line 11528) | void close() {
      method TablePrinter (line 11537) | TablePrinter& operator << (TablePrinter& tp, T const& value) {
      method TablePrinter (line 11542) | TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
      method TablePrinter (line 11565) | TablePrinter& operator << (TablePrinter& tp, RowBreak) {
    type ConsoleReporter (line 4035) | struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
    class XmlEncode (line 4099) | class XmlEncode {
      type ForWhat (line 4101) | enum ForWhat { ForTextNodes, ForAttributes }
    class XmlWriter (line 4114) | class XmlWriter {
      class ScopedElement (line 4117) | class ScopedElement {
        method ScopedElement (line 4129) | ScopedElement& writeAttribute( std::string const& name, T const& a...
      method XmlWriter (line 4141) | XmlWriter( XmlWriter const& ) = delete;
      method XmlWriter (line 4142) | XmlWriter& operator=( XmlWriter const& ) = delete;
      method XmlWriter (line 4155) | XmlWriter& writeAttribute( std::string const& name, T const& attribu...
    class JunitReporter (line 4189) | class JunitReporter : public CumulativeReporterBase<JunitReporter> {
    class XmlReporter (line 4237) | class XmlReporter : public StreamingReporterBase<XmlReporter> {
    type TestCaseTracking (line 4304) | namespace TestCaseTracking {
      type NameAndLocation (line 4306) | struct NameAndLocation {
      type ITracker (line 4313) | struct ITracker
      type ITracker (line 4317) | struct ITracker {
      class TrackerContext (line 4345) | class TrackerContext {
        type RunState (line 4347) | enum RunState {
      class TrackerBase (line 4372) | class TrackerBase : public ITracker {
        type CycleState (line 4374) | enum CycleState {
        class TrackerHasName (line 4383) | class TrackerHasName {
      class SectionTracker (line 4427) | class SectionTracker : public TrackerBase {
      class IndexTracker (line 4442) | class IndexTracker : public TrackerBase {
      function TrackerContext (line 9911) | TrackerContext& TrackerContext::instance() {
        type RunState (line 4347) | enum RunState {
      function ITracker (line 9916) | ITracker& TrackerContext::startRun() {
      function ITracker (line 9940) | ITracker& TrackerContext::currentTracker() {
      function NameAndLocation (line 9960) | NameAndLocation const& TrackerBase::nameAndLocation() const {
      function ITrackerPtr (line 9980) | ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLo...
      function ITracker (line 9986) | ITracker& TrackerBase::parent() {
      function SectionTracker (line 10071) | SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAn...
      function IndexTracker (line 10113) | IndexTracker& IndexTracker::acquire( TrackerContext& ctx, NameAndLoc...
    type LeakDetector (line 4473) | struct LeakDetector {
    type Detail (line 4496) | namespace Detail {
      function rawMemoryToString (line 715) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 720) | class IsStreamInsertable {
      function convertUnstreamable (line 736) | typename std::enable_if<!std::is_enum<T>::value, std::string>::type ...
      function convertUnstreamable (line 740) | typename std::enable_if<std::is_enum<T>::value, std::string>::type c...
      function stringify (line 771) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 776) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 923) | std::string rangeToString(InputIterator first, InputIterator last) {
      function stringify (line 953) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1001) | struct TupleElementPrinter {
        method print (line 1002) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1013) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1014) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 1983) | class Approx {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      function Approx (line 4505) | Approx Approx::custom() {
        method Approx (line 1993) | Approx operator()( T const& value ) {
        method Approx (line 2002) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 2047) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 2060) | Approx& margin( T const& newMargin ) {
        method Approx (line 2074) | Approx& scale( T const& newScale ) {
      type Endianness (line 10403) | struct Endianness {
        type Arch (line 10404) | enum Arch { Big, Little }
        method Arch (line 10406) | static Arch which() {
      function rawMemoryToString (line 10418) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type IResultCapture (line 4537) | struct IResultCapture
    type IRunner (line 4538) | struct IRunner
    type IConfig (line 4539) | struct IConfig
    type IMutableContext (line 4540) | struct IMutableContext
    type IContext (line 4544) | struct IContext
    type IMutableContext (line 4553) | struct IMutableContext : IContext
    function IMutableContext (line 4567) | inline IMutableContext& getCurrentMutableContext()
    function IContext (line 4574) | inline IContext& getCurrentContext()
    type FatalConditionHandler (line 4659) | struct FatalConditionHandler {
      type sigaction (line 4704) | struct sigaction
    type FatalConditionHandler (line 4668) | struct FatalConditionHandler {
      type sigaction (line 4704) | struct sigaction
    type FatalConditionHandler (line 4690) | struct FatalConditionHandler {
      type sigaction (line 4704) | struct sigaction
    type FatalConditionHandler (line 4701) | struct FatalConditionHandler {
      type sigaction (line 4704) | struct sigaction
    type IMutableContext (line 4726) | struct IMutableContext
    class RunContext (line 4730) | class RunContext : public IResultCapture, public IRunner {
      method RunContext (line 4733) | RunContext( RunContext const& ) = delete;
      method RunContext (line 4734) | RunContext& operator =( RunContext const& ) = delete;
    function handleExceptionMatchExpr (line 4935) | void handleExceptionMatchExpr( AssertionHandler& handler, std::string ...
    function SourceLineInfo (line 5022) | SourceLineInfo AssertionResult::getSourceInfo() const {
      method SourceLineInfo (line 241) | SourceLineInfo() = delete;
      method SourceLineInfo (line 242) | SourceLineInfo( char const* _file, std::size_t _line ) noexcept
      method SourceLineInfo (line 247) | SourceLineInfo( SourceLineInfo const& other )        = default;
      method SourceLineInfo (line 248) | SourceLineInfo( SourceLineInfo && )                  = default;
      method SourceLineInfo (line 249) | SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
      method SourceLineInfo (line 250) | SourceLineInfo& operator = ( SourceLineInfo && )     = default;
    function StringRef (line 5026) | StringRef AssertionResult::getTestMacroName() const {
      method StringRef (line 361) | StringRef() noexcept
      method StringRef (line 365) | StringRef( StringRef const& other ) noexcept
      method StringRef (line 370) | StringRef( StringRef&& other ) noexcept
      method StringRef (line 380) | StringRef( char const* rawChars, size_type size ) noexcept
      method StringRef (line 385) | StringRef( std::string const& stdString ) noexcept
      method empty (line 413) | auto empty() const noexcept -> bool {
      method size (line 416) | auto size() const noexcept -> size_type {
    function handleExceptionMatchExpr (line 5067) | void handleExceptionMatchExpr( AssertionHandler& handler, StringMatche...
    type clara (line 5129) | namespace clara { namespace TextFlow {
      type TextFlow (line 5129) | namespace TextFlow {
        function isWhitespace (line 5131) | inline auto isWhitespace( char c ) -> bool {
        function isBreakableBefore (line 5135) | inline auto isBreakableBefore( char c ) -> bool {
        function isBreakableAfter (line 5139) | inline auto isBreakableAfter( char c ) -> bool {
        class Columns (line 5144) | class Columns
          class iterator (line 5324) | class iterator {
            type EndTag (line 5326) | struct EndTag {}
            method iterator (line 5332) | iterator( Columns const& columns, EndTag )
            method iterator (line 5343) | explicit iterator( Columns const& columns )
          method begin (line 5393) | auto begin() const -> iterator { return iterator( *this ); }
          method end (line 5394) | auto end() const -> iterator { return { *this, iterator::EndTag(...
          method friend (line 5406) | inline friend std::ostream& operator << ( std::ostream& os, Colu...
          method toString (line 5419) | auto toString() const -> std::string {
        class Column (line 5146) | class Column {
          class iterator (line 5153) | class iterator {
            method iterator (line 5164) | iterator( Column const& column, size_t stringIndex )
            method line (line 5169) | auto line() const -> std::string const& { return m_column.m_st...
            method isBoundary (line 5171) | auto isBoundary( size_t at ) const -> bool {
            method calcLength (line 5181) | void calcLength() {
            method indent (line 5209) | auto indent() const -> size_t {
            method addIndentAndSuffix (line 5214) | auto addIndentAndSuffix(std::string const &plain) const -> std...
            method iterator (line 5219) | explicit iterator( Column const& column ) : m_column( column ) {
          method Column (line 5270) | explicit Column( std::string const& text ) { m_strings.push_back...
          method width (line 5272) | auto width( size_t newWidth ) -> Column& {
          method indent (line 5277) | auto indent( size_t newIndent ) -> Column& {
          method initialIndent (line 5281) | auto initialIndent( size_t newIndent ) -> Column& {
          method width (line 5286) | auto width() const -> size_t { return m_width; }
          method begin (line 5287) | auto begin() const -> iterator { return iterator( *this ); }
          method end (line 5288) | auto end() const -> iterator { return { *this, m_strings.size() ...
          method friend (line 5290) | inline friend std::ostream& operator << ( std::ostream& os, Colu...
          method toString (line 5304) | auto toString() const -> std::string {
        class Spacer (line 5311) | class Spacer : public Column {
          method Spacer (line 5314) | explicit Spacer( size_t spaceWidth ) : Column( "" ) {
        class Columns (line 5319) | class Columns {
          class iterator (line 5324) | class iterator {
            type EndTag (line 5326) | struct EndTag {}
            method iterator (line 5332) | iterator( Columns const& columns, EndTag )
            method iterator (line 5343) | explicit iterator( Columns const& columns )
          method begin (line 5393) | auto begin() const -> iterator { return iterator( *this ); }
          method end (line 5394) | auto end() const -> iterator { return { *this, iterator::EndTag(...
          method friend (line 5406) | inline friend std::ostream& operator << ( std::ostream& os, Colu...
          method toString (line 5419) | auto toString() const -> std::string {
      type detail (line 5446) | namespace detail {
        type UnaryLambdaTraits (line 5450) | struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operato...
        type UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> (line 5458) | struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
        class TokenStream (line 5464) | class TokenStream
          method loadBuffer (line 5514) | void loadBuffer() {
          method TokenStream (line 5546) | explicit TokenStream( Args const &args ) : TokenStream( args.m_a...
          method TokenStream (line 5548) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( it...
          method count (line 5556) | auto count() const -> size_t { return m_tokenBuffer.size() + (it...
        class Args (line 5467) | class Args {
          method Args (line 5473) | Args( int argc, char *argv[] ) {
          method Args (line 5479) | Args( std::initializer_list<std::string> args )
          method exeName (line 5484) | auto exeName() const -> std::string {
        type TokenType (line 5491) | enum class TokenType {
        type Token (line 5494) | struct Token {
        function isOptPrefix (line 5499) | inline auto isOptPrefix( char c ) -> bool {
        class TokenStream (line 5508) | class TokenStream {
          method loadBuffer (line 5514) | void loadBuffer() {
          method TokenStream (line 5546) | explicit TokenStream( Args const &args ) : TokenStream( args.m_a...
          method TokenStream (line 5548) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( it...
          method count (line 5556) | auto count() const -> size_t { return m_tokenBuffer.size() + (it...
        class ResultBase (line 5580) | class ResultBase {
          type Type (line 5582) | enum Type {
          method ResultBase (line 5587) | ResultBase( Type type ) : m_type( type ) {}
        class ResultValueBase (line 5596) | class ResultValueBase : public ResultBase {
          method value (line 5598) | auto value() const -> T const & {
          method ResultValueBase (line 5604) | ResultValueBase( Type type ) : ResultBase( type ) {}
          method ResultValueBase (line 5606) | ResultValueBase( ResultValueBase const &other ) : ResultBase( ot...
          method ResultValueBase (line 5611) | ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
        class ResultValueBase<void> (line 5635) | class ResultValueBase<void> : public ResultBase {
        class BasicResult (line 5641) | class BasicResult : public ResultValueBase<T> {
          method BasicResult (line 5644) | explicit BasicResult( BasicResult<U> const &other )
          method ok (line 5652) | static auto ok( U const &value ) -> BasicResult { return { Resul...
          method ok (line 5653) | static auto ok() -> BasicResult { return { ResultBase::Ok }; }
          method logicError (line 5654) | static auto logicError( std::string const &message ) -> BasicRes...
          method runtimeError (line 5655) | static auto runtimeError( std::string const &message ) -> BasicR...
          method type (line 5658) | auto type() const -> ResultBase::Type { return m_type; }
          method errorMessage (line 5659) | auto errorMessage() const -> std::string { return m_errorMessage; }
          method enforceOk (line 5662) | virtual void enforceOk() const {
          method BasicResult (line 5676) | BasicResult( ResultBase::Type type, std::string const &message )
        type ParseResultType (line 5687) | enum class ParseResultType {
        class ParseState (line 5691) | class ParseState {
          method ParseState (line 5694) | ParseState( ParseResultType type, TokenStream const &remainingTo...
          method type (line 5699) | auto type() const -> ParseResultType { return m_type; }
          method remainingTokens (line 5700) | auto remainingTokens() const -> TokenStream { return m_remaining...
        type HelpColumns (line 5711) | struct HelpColumns {
        function convertInto (line 5717) | inline auto convertInto( std::string const &source, T& target ) ->...
        function convertInto (line 5726) | inline auto convertInto( std::string const &source, std::string& t...
        function convertInto (line 5730) | inline auto convertInto( std::string const &source, bool &target )...
        type BoundRefBase (line 5742) | struct BoundRefBase {
          method BoundRefBase (line 5743) | BoundRefBase() = default;
          method BoundRefBase (line 5744) | BoundRefBase( BoundRefBase const & ) = delete;
          method BoundRefBase (line 5745) | BoundRefBase( BoundRefBase && ) = delete;
          method BoundRefBase (line 5746) | BoundRefBase &operator=( BoundRefBase const & ) = delete;
          method BoundRefBase (line 5747) | BoundRefBase &operator=( BoundRefBase && ) = delete;
          method isContainer (line 5752) | virtual auto isContainer() const -> bool { return false; }
        type BoundValueRefBase (line 5757) | struct BoundValueRefBase : BoundRefBase {
          method isFlag (line 5758) | auto isFlag() const -> bool override { return false; }
          method setFlag (line 5760) | auto setFlag( bool ) -> ParserResult override {
        type BoundFlagRefBase (line 5765) | struct BoundFlagRefBase : BoundRefBase {
          method isFlag (line 5766) | auto isFlag() const -> bool override { return true; }
          method setValue (line 5768) | auto setValue( std::string const &arg ) -> ParserResult override {
        type BoundRef (line 5778) | struct BoundRef : BoundValueRefBase {
          method BoundRef (line 5781) | explicit BoundRef( T &ref ) : m_ref( ref ) {}
          method setValue (line 5783) | auto setValue( std::string const &arg ) -> ParserResult override {
        type BoundRef<std::vector<T>> (line 5789) | struct BoundRef<std::vector<T>> : BoundValueRefBase {
          method BoundRef (line 5792) | explicit BoundRef( std::vector<T> &ref ) : m_ref( ref ) {}
          method isContainer (line 5794) | auto isContainer() const -> bool override { return true; }
          method setValue (line 5796) | auto setValue( std::string const &arg ) -> ParserResult override {
        type BoundFlagRef (line 5805) | struct BoundFlagRef : BoundFlagRefBase {
          method BoundFlagRef (line 5808) | explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
          method setFlag (line 5810) | auto setFlag( bool flag ) -> ParserResult override {
        type LambdaInvoker (line 5817) | struct LambdaInvoker {
          method invoke (line 5821) | static auto invoke( L const &lambda, ArgType const &arg ) -> Par...
        type LambdaInvoker<void> (line 5827) | struct LambdaInvoker<void> {
          method invoke (line 5829) | static auto invoke( L const &lambda, ArgType const &arg ) -> Par...
        function invokeLambda (line 5836) | inline auto invokeLambda( L const &lambda, std::string const &arg ...
        type BoundLambda (line 5845) | struct BoundLambda : BoundValueRefBase {
          method BoundLambda (line 5849) | explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
          method setValue (line 5851) | auto setValue( std::string const &arg ) -> ParserResult override {
        type BoundFlagLambda (line 5857) | struct BoundFlagLambda : BoundFlagRefBase {
          method BoundFlagLambda (line 5863) | explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
          method setFlag (line 5865) | auto setFlag( bool flag ) -> ParserResult override {
        type Optionality (line 5870) | enum class Optionality { Optional, Required }
        type Parser (line 5872) | struct Parser
          method getHelpColumns (line 6164) | auto getHelpColumns() const -> std::vector<HelpColumns> {
          method writeToStream (line 6173) | void writeToStream( std::ostream &os ) const {
          method validate (line 6217) | auto validate() const -> Result override {
          method parse (line 6233) | auto parse( std::string const& exeName, TokenStream const &token...
        class ParserBase (line 5874) | class ParserBase {
          method validate (line 5877) | virtual auto validate() const -> Result { return Result::ok(); }
          method cardinality (line 5879) | virtual auto cardinality() const -> size_t { return 1; }
          method parse (line 5881) | auto parse( Args const &args ) const -> InternalParseResult {
        class ComposableParserImpl (line 5887) | class ComposableParserImpl : public ParserBase {
        class ParserRefImpl (line 5895) | class ParserRefImpl : public ComposableParserImpl<DerivedT> {
          method ParserRefImpl (line 5902) | explicit ParserRefImpl( std::shared_ptr<BoundRefBase> const &ref...
          method ParserRefImpl (line 5906) | ParserRefImpl( T &ref, std::string const &hint )
          method ParserRefImpl (line 5912) | ParserRefImpl( LambdaT const &ref, std::string const &hint )
          method optional (line 5922) | auto optional() -> DerivedT & {
          method required (line 5927) | auto required() -> DerivedT & {
          method isOptional (line 5932) | auto isOptional() const -> bool {
          method cardinality (line 5936) | auto cardinality() const -> size_t override {
          method hint (line 5943) | auto hint() const -> std::string { return m_hint; }
        class ExeName (line 5946) | class ExeName : public ComposableParserImpl<ExeName> {
          method makeRef (line 5951) | static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<Bo...
          method ExeName (line 5956) | ExeName() : m_name( std::make_shared<std::string>( "<executable>...
          method ExeName (line 5958) | explicit ExeName( std::string &ref ) : ExeName() {
          method ExeName (line 5963) | explicit ExeName( LambdaT const& lambda ) : ExeName() {
          method parse (line 5968) | auto parse( std::string const&, TokenStream const &tokens ) cons...
          method name (line 5972) | auto name() const -> std::string { return *m_name; }
          method set (line 5973) | auto set( std::string const& newName ) -> ParserResult {
        class Arg (line 5988) | class Arg : public ParserRefImpl<Arg> {
          method parse (line 5992) | auto parse( std::string const &, TokenStream const &tokens ) con...
        function normaliseOpt (line 6010) | inline auto normaliseOpt( std::string const &optName ) -> std::str...
        class Opt (line 6019) | class Opt : public ParserRefImpl<Opt> {
          method Opt (line 6025) | explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_sh...
          method Opt (line 6027) | explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<Boun...
          method Opt (line 6030) | Opt( LambdaT const &ref, std::string const &hint ) : ParserRefIm...
          method Opt (line 6033) | Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hin...
          method getHelpColumns (line 6040) | auto getHelpColumns() const -> std::vector<HelpColumns> {
          method isMatch (line 6055) | auto isMatch( std::string const &optToken ) const -> bool {
          method parse (line 6066) | auto parse( std::string const&, TokenStream const &tokens ) cons...
          method validate (line 6100) | auto validate() const -> Result override {
        type Help (line 6118) | struct Help : Opt {
          method Help (line 6119) | Help( bool &showHelpFlag )
        type Parser (line 6132) | struct Parser : ParserBase {
          method getHelpColumns (line 6164) | auto getHelpColumns() const -> std::vector<HelpColumns> {
          method writeToStream (line 6173) | void writeToStream( std::ostream &os ) const {
          method validate (line 6217) | auto validate() const -> Result override {
          method parse (line 6233) | auto parse( std::string const& exeName, TokenStream const &token...
    type clara (line 5445) | namespace clara {
      type TextFlow (line 5129) | namespace TextFlow {
        function isWhitespace (line 5131) | inline auto isWhitespace( char c ) -> bool {
        function isBreakableBefore (line 5135) | inline auto isBreakableBefore( char c ) -> bool {
        function isBreakableAfter (line 5139) | inline auto isBreakableAfter( char c ) -> bool {
        class Columns (line 5144) | class Columns
          class iterator (line 5324) | class iterator {
            type EndTag (line 5326) | struct EndTag {}
            method iterator (line 5332) | iterator( Columns const& columns, EndTag )
            method iterator (line 5343) | explicit iterator( Columns const& columns )
          method begin (line 5393) | auto begin() const -> iterator { return iterator( *this ); }
          method end (line 5394) | auto end() const -> iterator { return { *this, iterator::EndTag(...
          method friend (line 5406) | inline friend std::ostream& operator << ( std::ostream& os, Colu...
          method toString (line 5419) | auto toString() const -> std::string {
        class Column (line 5146) | class Column {
          class iterator (line 5153) | class iterator {
            method iterator (line 5164) | iterator( Column const& column, size_t stringIndex )
            method line (line 5169) | auto line() const -> std::string const& { return m_column.m_st...
            method isBoundary (line 5171) | auto isBoundary( size_t at ) const -> bool {
            method calcLength (line 5181) | void calcLength() {
            method indent (line 5209) | auto indent() const -> size_t {
            method addIndentAndSuffix (line 5214) | auto addIndentAndSuffix(std::string const &plain) const -> std...
            method iterator (line 5219) | explicit iterator( Column const& column ) : m_column( column ) {
          method Column (line 5270) | explicit Column( std::string const& text ) { m_strings.push_back...
          method width (line 5272) | auto width( size_t newWidth ) -> Column& {
          method indent (line 5277) | auto indent( size_t newIndent ) -> Column& {
          method initialIndent (line 5281) | auto initialIndent( size_t newIndent ) -> Column& {
          method width (line 5286) | auto width() const -> size_t { return m_width; }
          method begin (line 5287) | auto begin() const -> iterator { return iterator( *this ); }
          method end (line 5288) | auto end() const -> iterator { return { *this, m_strings.size() ...
          method friend (line 5290) | inline friend std::ostream& operator << ( std::ostream& os, Colu...
          method toString (line 5304) | auto toString() const -> std::string {
        class Spacer (line 5311) | class Spacer : public Column {
          method Spacer (line 5314) | explicit Spacer( size_t spaceWidth ) : Column( "" ) {
        class Columns (line 5319) | class Columns {
          class iterator (line 5324) | class iterator {
            type EndTag (line 5326) | struct EndTag {}
            method iterator (line 5332) | iterator( Columns const& columns, EndTag )
            method iterator (line 5343) | explicit iterator( Columns const& columns )
          method begin (line 5393) | auto begin() const -> iterator { return iterator( *this ); }
          method end (line 5394) | auto end() const -> iterator { return { *this, iterator::EndTag(...
          method friend (line 5406) | inline friend std::ostream& operator << ( std::ostream& os, Colu...
          method toString (line 5419) | auto toString() const -> std::string {
      type detail (line 5446) | namespace detail {
        type UnaryLambdaTraits (line 5450) | struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operato...
        type UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> (line 5458) | struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
        class TokenStream (line 5464) | class TokenStream
          method loadBuffer (line 5514) | void loadBuffer() {
          method TokenStream (line 5546) | explicit TokenStream( Args const &args ) : TokenStream( args.m_a...
          method TokenStream (line 5548) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( it...
          method count (line 5556) | auto count() const -> size_t { return m_tokenBuffer.size() + (it...
        class Args (line 5467) | class Args {
          method Args (line 5473) | Args( int argc, char *argv[] ) {
          method Args (line 5479) | Args( std::initializer_list<std::string> args )
          method exeName (line 5484) | auto exeName() const -> std::string {
        type TokenType (line 5491) | enum class TokenType {
        type Token (line 5494) | struct Token {
        function isOptPrefix (line 5499) | inline auto isOptPrefix( char c ) -> bool {
        class TokenStream (line 5508) | class TokenStream {
          method loadBuffer (line 5514) | void loadBuffer() {
          method TokenStream (line 5546) | explicit TokenStream( Args const &args ) : TokenStream( args.m_a...
          method TokenStream (line 5548) | TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( it...
          method count (line 5556) | auto count() const -> size_t { return m_tokenBuffer.size() + (it...
        class ResultBase (line 5580) | class ResultBase {
          type Type (line 5582) | enum Type {
          method ResultBase (line 5587) | ResultBase( Type type ) : m_type( type ) {}
        class ResultValueBase (line 5596) | class ResultValueBase : public ResultBase {
          method value (line 5598) | auto value() const -> T const & {
          method ResultValueBase (line 5604) | ResultValueBase( Type type ) : ResultBase( type ) {}
          method ResultValueBase (line 5606) | ResultValueBase( ResultValueBase const &other ) : ResultBase( ot...
          method ResultValueBase (line 5611) | ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
        class ResultValueBase<void> (line 5635) | class ResultValueBase<void> : public ResultBase {
        class BasicResult (line 5641) | class BasicResult : public ResultValueBase<T> {
          method BasicResult (line 5644) | explicit BasicResult( BasicResult<U> const &other )
          method ok (line 5652) | static auto ok( U const &value ) -> BasicResult { return { Resul...
          method ok (line 5653) | static auto ok() -> BasicResult { return { ResultBase::Ok }; }
          method logicError (line 5654) | static auto logicError( std::string const &message ) -> BasicRes...
          method runtimeError (line 5655) | static auto runtimeError( std::string const &message ) -> BasicR...
          method type (line 5658) | auto type() const -> ResultBase::Type { return m_type; }
          method errorMessage (line 5659) | auto errorMessage() const -> std::string { return m_errorMessage; }
          method enforceOk (line 5662) | virtual void enforceOk() const {
          method BasicResult (line 5676) | BasicResult( ResultBase::Type type, std::string const &message )
        type ParseResultType (line 5687) | enum class ParseResultType {
        class ParseState (line 5691) | class ParseState {
          method ParseState (line 5694) | ParseState( ParseResultType type, TokenStream const &remainingTo...
          method type (line 5699) | auto type() const -> ParseResultType { return m_type; }
          method remainingTokens (line 5700) | auto remainingTokens() const -> TokenStream { return m_remaining...
        type HelpColumns (line 5711) | struct HelpColumns {
        function convertInto (line 5717) | inline auto convertInto( std::string const &source, T& target ) ->...
        function convertInto (line 5726) | inline auto convertInto( std::string const &source, std::string& t...
        function convertInto (line 5730) | inline auto convertInto( std::string const &source, bool &target )...
        type BoundRefBase (line 5742) | struct BoundRefBase {
          method BoundRefBase (line 5743) | BoundRefBase() = default;
          method BoundRefBase (line 5744) | BoundRefBase( BoundRefBase const & ) = delete;
          method BoundRefBase (line 5745) | BoundRefBase( BoundRefBase && ) = delete;
          method BoundRefBase (line 5746) | BoundRefBase &operator=( BoundRefBase const & ) = delete;
          method BoundRefBase (line 5747) | BoundRefBase &operator=( BoundRefBase && ) = delete;
          method isContainer (line 5752) | virtual auto isContainer() const -> bool { return false; }
        type BoundValueRefBase (line 5757) | struct BoundValueRefBase : BoundRefBase {
          method isFlag (line 5758) | auto isFlag() const -> bool override { return false; }
          method setFlag (line 5760) | auto setFlag( bool ) -> ParserResult override {
        type BoundFlagRefBase (line 5765) | struct BoundFlagRefBase : BoundRefBase {
          method isFlag (line 5766) | auto isFlag() const -> bool override { return true; }
          method setValue (line 5768) | auto setValue( std::string const &arg ) -> ParserResult override {
        type BoundRef (line 5778) | struct BoundRef : BoundValueRefBase {
          method BoundRef (line 5781) | explicit BoundRef( T &ref ) : m_ref( ref ) {}
          method setValue (line 5783) | auto setValue( std::string const &arg ) -> ParserResult override {
        type BoundRef<std::vector<T>> (line 5789) | struct BoundRef<std::vector<T>> : BoundValueRefBase {
          method BoundRef (line 5792) | explicit BoundRef( std::vector<T> &ref ) : m_ref( ref ) {}
          method isContainer (line 5794) | auto isContainer() const -> bool override { return true; }
          method setValue (line 5796) | auto setValue( std::string const &arg ) -> ParserResult override {
        type BoundFlagRef (line 5805) | struct BoundFlagRef : BoundFlagRefBase {
          method BoundFlagRef (line 5808) | explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
          method setFlag (line 5810) | auto setFlag( bool flag ) -> ParserResult override {
        type LambdaInvoker (line 5817) | struct LambdaInvoker {
          method invoke (line 5821) | static auto invoke( L const &lambda, ArgType const &arg ) -> Par...
        type LambdaInvoker<void> (line 5827) | struct LambdaInvoker<void> {
          method invoke (line 5829) | static auto invoke( L const &lambda, ArgType const &arg ) -> Par...
        function invokeLambda (line 5836) | inline auto invokeLambda( L const &lambda, std::string const &arg ...
        type BoundLambda (line 5845) | struct BoundLambda : BoundValueRefBase {
          method BoundLambda (line 5849) | explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
          method setValue (line 5851) | auto setValue( std::string const &arg ) -> ParserResult override {
        type BoundFlagLambda (line 5857) | struct BoundFlagLambda : BoundFlagRefBase {
          method BoundFlagLambda (line 5863) | explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
          method setFlag (line 5865) | auto setFlag( bool flag ) -> ParserResult override {
        type Optionality (line 5870) | enum class Optionality { Optional, Required }
        type Parser (line 5872) | struct Parser
          method getHelpColumns (line 6164) | auto getHelpColumns() const -> std::vector<HelpColumns> {
          method writeToStream (line 6173) | void writeToStream( std::ostream &os ) const {
          method validate (line 6217) | auto validate() const -> Result override {
          method parse (line 6233) | auto parse( std::string const& exeName, TokenStream const &token...
        class ParserBase (line 5874) | class ParserBase {
          method validate (line 5877) | virtual auto validate() const -> Result { return Result::ok(); }
          method cardinality (line 5879) | virtual auto cardinality() const -> size_t { return 1; }
          method parse (line 5881) | auto parse( Args const &args ) const -> InternalParseResult {
        class ComposableParserImpl (line 5887) | class ComposableParserImpl : public ParserBase {
        class ParserRefImpl (line 5895) | class ParserRefImpl : public ComposableParserImpl<DerivedT> {
          method ParserRefImpl (line 5902) | explicit ParserRefImpl( std::shared_ptr<BoundRefBase> const &ref...
          method ParserRefImpl (line 5906) | ParserRefImpl( T &ref, std::string const &hint )
          method ParserRefImpl (line 5912) | ParserRefImpl( LambdaT const &ref, std::string const &hint )
          method optional (line 5922) | auto optional() -> DerivedT & {
          method required (line 5927) | auto required() -> DerivedT & {
          method isOptional (line 5932) | auto isOptional() const -> bool {
          method cardinality (line 5936) | auto cardinality() const -> size_t override {
          method hint (line 5943) | auto hint() const -> std::string { return m_hint; }
        class ExeName (line 5946) | class ExeName : public ComposableParserImpl<ExeName> {
          method makeRef (line 5951) | static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<Bo...
          method ExeName (line 5956) | ExeName() : m_name( std::make_shared<std::string>( "<executable>...
          method ExeName (line 5958) | explicit ExeName( std::string &ref ) : ExeName() {
          method ExeName (line 5963) | explicit ExeName( LambdaT const& lambda ) : ExeName() {
          method parse (line 5968) | auto parse( std::string const&, TokenStream const &tokens ) cons...
          method name (line 5972) | auto name() const -> std::string { return *m_name; }
          method set (line 5973) | auto set( std::string const& newName ) -> ParserResult {
        class Arg (line 5988) | class Arg : public ParserRefImpl<Arg> {
          method parse (line 5992) | auto parse( std::string const &, TokenStream const &tokens ) con...
        function normaliseOpt (line 6010) | inline auto normaliseOpt( std::string const &optName ) -> std::str...
        class Opt (line 6019) | class Opt : public ParserRefImpl<Opt> {
          method Opt (line 6025) | explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_sh...
          method Opt (line 6027) | explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<Boun...
          method Opt (line 6030) | Opt( LambdaT const &ref, std::string const &hint ) : ParserRefIm...
          method Opt (line 6033) | Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hin...
          method getHelpColumns (line 6040) | auto getHelpColumns() const -> std::vector<HelpColumns> {
          method isMatch (line 6055) | auto isMatch( std::string const &optToken ) const -> bool {
          method parse (line 6066) | auto parse( std::string const&, TokenStream const &tokens ) cons...
          method validate (line 6100) | auto validate() const -> Result override {
        type Help (line 6118) | struct Help : Opt {
          method Help (line 6119) | Help( bool &showHelpFlag )
        type Parser (line 6132) | struct Parser : ParserBase {
          method getHelpColumns (line 6164) | auto getHelpColumns() const -> std::vector<HelpColumns> {
          method writeToStream (line 6173) | void writeToStream( std::ostream &os ) const {
          method validate (line 6217) | auto validate() const -> Result override {
          method parse (line 6233) | auto parse( std::string const& exeName, TokenStream const &token...
    function makeCommandLineParser (line 6337) | clara::Parser makeCommandLineParser( ConfigData& config ) {
    function TestSpec (line 6585) | TestSpec const& Config::testSpec() const { return m_testSpec; }
      type Pattern (line 2984) | struct Pattern {
      class NamePattern (line 2990) | class NamePattern : public Pattern {
      class TagPattern (line 2999) | class TagPattern : public Pattern {
      class ExcludedPattern (line 3008) | class ExcludedPattern : public Pattern {
      type Filter (line 3017) | struct Filter {
    function Verbosity (line 6603) | Verbosity Config::verbosity() const                { return m_data.ver...
    function IStream (line 6605) | IStream const* Config::openStream() {
    class ErrnoGuard (line 6622) | class ErrnoGuard {
    type IColourImpl (line 6638) | struct IColourImpl {
    type NoColourImpl (line 6643) | struct NoColourImpl : IColourImpl {
      method use (line 6644) | void use( Colour::Code ) {}
      method IColourImpl (line 6646) | static IColourImpl* instance() {
    class Win32ColourImpl (line 6668) | class Win32ColourImpl : public IColourImpl {
      method Win32ColourImpl (line 6670) | Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
      method use (line 6678) | virtual void use( Colour::Code _colourCode ) override {
      method setTextAttribute (line 6699) | void setTextAttribute( WORD _textAttribute ) {
    function IColourImpl (line 6707) | IColourImpl* platformColourInstance() {
    class PosixColourImpl (line 6735) | class PosixColourImpl : public IColourImpl {
      method use (line 6737) | virtual void use( Colour::Code _colourCode ) override {
      method IColourImpl (line 6756) | static IColourImpl* instance() {
      method setColour (line 6762) | void setColour( const char* _escapeCode ) {
    function useColourOnPlatform (line 6767) | bool useColourOnPlatform() {
    function IColourImpl (line 6774) | IColourImpl* platformColourInstance() {
    function IColourImpl (line 6796) | static IColourImpl* platformColourInstance() { return NoColourImpl::in...
    function Colour (line 6809) | Colour& Colour::operator=( Colour&& rhs ) noexcept {
      type Code (line 3872) | enum Code {
    class Context (line 6837) | class Context : public IMutableContext, NonCopyable {
      method IResultCapture (line 6840) | virtual IResultCapture* getResultCapture() override {
      method IRunner (line 6843) | virtual IRunner* getRunner() override {
      method IConfigPtr (line 6847) | virtual IConfigPtr const& getConfig() const override {
      method setResultCapture (line 6854) | virtual void setResultCapture( IResultCapture* resultCapture ) overr...
      method setRunner (line 6857) | virtual void setRunner( IRunner* runner ) override {
      method setConfig (line 6860) | virtual void setConfig( IConfigPtr const& config ) override {
    function cleanUpContext (line 6879) | void cleanUpContext() {
    function writeToDebugConsole (line 6902) | void writeToDebugConsole( std::string const& text ) {
    function writeToDebugConsole (line 6908) | void writeToDebugConsole( std::string const& text ) {
    function isDebuggerActive (line 6934) | bool isDebuggerActive(){
    function isDebuggerActive (line 6979) | bool isDebuggerActive(){
    function isDebuggerActive (line 7000) | bool isDebuggerActive() {
    function isDebuggerActive (line 7007) | bool isDebuggerActive() {
    function isDebuggerActive (line 7013) | bool isDebuggerActive() { return false; }
    function formatReconstructedExpression (line 7023) | void formatReconstructedExpression( std::ostream &os, std::string cons...
    class ExceptionTranslatorRegistry (line 7052) | class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
    type SignalDefs (line 7142) | struct SignalDefs { DWORD id; const char* name; }
    function LONG (line 7154) | LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTIO...
    type SignalDefs (line 7213) | struct SignalDefs {
    type sigaction (line 7246) | struct sigaction
    type sigaction (line 7272) | struct sigaction
    class MultipleReporters (line 7318) | class MultipleReporters : public IStreamingReporter {
    function IConfigPtr (line 7366) | IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
    function addReporter (line 7457) | void addReporter( IStreamingReporterPtr& existingReporter, IStreamingR...
    type TagInfo (line 7530) | struct TagInfo {
    function listTests (line 7560) | std::size_t listTests( Config const& config ) {
    function listTestsNamesOnly (line 7595) | std::size_t listTestsNamesOnly( Config const& config ) {
    function listTags (line 7626) | std::size_t listTags( Config const& config ) {
    function listReporters (line 7662) | std::size_t listReporters( Config const& /*config*/ ) {
    function list (line 7684) | Option<std::size_t> list( Config const& config ) {
    type Matchers (line 7702) | namespace Matchers {
      type Impl (line 2135) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 2283) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type StdString (line 2325) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 2394) | namespace Vector {
        type Detail (line 2395) | namespace Detail {
          function count (line 2397) | size_t count(InputIterator first, InputIterator last, T const& i...
          function contains (line 2407) | bool contains(InputIterator first, InputIterator last, T const& ...
        type ContainsElementMatcher (line 2418) | struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
          method ContainsElementMatcher (line 2420) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 2422) | bool match(std::vector<T> const &v) const override {
          method describe (line 2431) | std::string describe() const override {
        type ContainsMatcher (line 2439) | struct ContainsMatcher : MatcherBase<std::vector<T>> {
          method ContainsMatcher (line 2441) | ContainsMatcher(std::vector<T> const &comparator) : m_comparator...
          method match (line 2443) | bool match(std::vector<T> const &v) const override {
          method describe (line 2461) | std::string describe() const override {
        type EqualsMatcher (line 2469) | struct EqualsMatcher : MatcherBase<std::vector<T>> {
          method EqualsMatcher (line 2471) | EqualsMatcher(std::vector<T> const &comparator) : m_comparator( ...
          method match (line 2473) | bool match(std::vector<T> const &v) const override {
          method describe (line 2485) | std::string describe() const override {
        type UnorderedEqualsMatcher (line 2492) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
          method UnorderedEqualsMatcher (line 2493) | UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(...
          method match (line 2494) | bool match(std::vector<T> const& vec) const override {
          method describe (line 2524) | std::string describe() const override {
      function Contains (line 2537) | Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparato...
      function VectorContains (line 2542) | Vector::ContainsElementMatcher<T> VectorContains( T const& comparato...
      function Equals (line 2547) | Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
      function UnorderedEquals (line 2552) | Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> con...
      type Impl (line 7703) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 7730) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type Floating (line 7791) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 7833) | Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
      function WithinULP (line 7837) | Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
      function WithinAbs (line 7841) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      type StdString (line 7856) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 7931) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 7934) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 7937) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 7940) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 7944) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 7729) | namespace Matchers {
      type Impl (line 2135) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
      type Floating (line 2283) | namespace Floating {
        type FloatingPointKind (line 2285) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 2287) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 2296) | struct WithinUlpsMatcher : MatcherBase<double> {
        type FloatingPointKind (line 7731) | enum class FloatingPointKind : uint8_t {
      type StdString (line 2325) | namespace StdString {
        type CasedString (line 2327) | struct CasedString
        type StringMatcherBase (line 2337) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 2345) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 2349) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 2353) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 2357) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 2362) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 2394) | namespace Vector {
        type Detail (line 2395) | namespace Detail {
          function count (line 2397) | size_t count(InputIterator first, InputIterator last, T const& i...
          function contains (line 2407) | bool contains(InputIterator first, InputIterator last, T const& ...
        type ContainsElementMatcher (line 2418) | struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
          method ContainsElementMatcher (line 2420) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 2422) | bool match(std::vector<T> const &v) const override {
          method describe (line 2431) | std::string describe() const override {
        type ContainsMatcher (line 2439) | struct ContainsMatcher : MatcherBase<std::vector<T>> {
          method ContainsMatcher (line 2441) | ContainsMatcher(std::vector<T> const &comparator) : m_comparator...
          method match (line 2443) | bool match(std::vector<T> const &v) const override {
          method describe (line 2461) | std::string describe() const override {
        type EqualsMatcher (line 2469) | struct EqualsMatcher : MatcherBase<std::vector<T>> {
          method EqualsMatcher (line 2471) | EqualsMatcher(std::vector<T> const &comparator) : m_comparator( ...
          method match (line 2473) | bool match(std::vector<T> const &v) const override {
          method describe (line 2485) | std::string describe() const override {
        type UnorderedEqualsMatcher (line 2492) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
          method UnorderedEqualsMatcher (line 2493) | UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(...
          method match (line 2494) | bool match(std::vector<T> const& vec) const override {
          method describe (line 2524) | std::string describe() const override {
      function Contains (line 2537) | Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparato...
      function VectorContains (line 2542) | Vector::ContainsElementMatcher<T> VectorContains( T const& comparato...
      function Equals (line 2547) | Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
      function UnorderedEquals (line 2552) | Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> con...
      type Impl (line 7703) | namespace Impl {
        type MatchAllOf (line 2137) | struct MatchAllOf
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2138) | struct MatchAnyOf
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2139) | struct MatchNotOf
          method MatchNotOf (line 2240) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 2242) | bool match( ArgT const& arg ) const override {
          method describe (line 2246) | std::string describe() const override {
        class MatcherUntypedBase (line 2141) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 2143) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 2144) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 2145) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 2155) | struct MatcherMethod {
        type MatcherMethod<PtrT*> (line 2159) | struct MatcherMethod<PtrT*> {
        type MatcherBase (line 2164) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 2172) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 2173) | bool match( ArgT const& arg ) const override {
          method describe (line 2180) | std::string describe() const override {
        type MatchAnyOf (line 2204) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 2206) | bool match( ArgT const& arg ) const override {
          method describe (line 2213) | std::string describe() const override {
        type MatchNotOf (line 2238) | struc
Condensed preview — 32 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (641K chars).
[
  {
    "path": ".gitattributes",
    "chars": 610,
    "preview": "# This sets the default behaviour, overriding core.autocrlf\n* text=auto\n\n# All source files should have unix line-ending"
  },
  {
    "path": ".gitignore",
    "chars": 241,
    "preview": ".idea/*.iml\n.idea/misc.xml\n.idea/modules.xml\n.idea/vcs.xml\n.idea/workspace.xml\n.idea/.name\n.idea/dictionaries/*\ncmake-bu"
  },
  {
    "path": ".travis.yml",
    "chars": 4547,
    "preview": "language: cpp\nsudo: false\n\ncommon_sources: &all_sources\n  - ubuntu-toolchain-r-test\n  - llvm-toolchain-trusty\n  - llvm-t"
  },
  {
    "path": "CMake/FindGcov.cmake",
    "chars": 5086,
    "preview": "# This file is part of CMake-codecov.\n#\n# Copyright (c)\n#   2015-2017 RWTH Aachen University, Federal Republic of German"
  },
  {
    "path": "CMake/FindLcov.cmake",
    "chars": 12328,
    "preview": "# This file is part of CMake-codecov.\n#\n# Copyright (c)\n#   2015-2017 RWTH Aachen University, Federal Republic of German"
  },
  {
    "path": "CMake/Findcodecov.cmake",
    "chars": 8419,
    "preview": "# This file is part of CMake-codecov.\n#\n# Copyright (c)\n#   2015-2017 RWTH Aachen University, Federal Republic of German"
  },
  {
    "path": "CMake/llvm-cov-wrapper",
    "chars": 1071,
    "preview": "#!/bin/sh\n\n# This file is part of CMake-codecov.\n#\n# Copyright (c)\n#   2015-2017 RWTH Aachen University, Federal Republi"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 1236,
    "preview": "cmake_minimum_required(VERSION 3.8.2)\nproject(Clara)\n\nset(SOURCE_FILES src/main.cpp src/ClaraTests.cpp include/clara.hpp"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 3214,
    "preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
  },
  {
    "path": "LICENSE.txt",
    "chars": 1338,
    "preview": "Boost Software License - Version 1.0 - August 17th, 2003\n\nPermission is hereby granted, free of charge, to any person or"
  },
  {
    "path": "README.md",
    "chars": 4672,
    "preview": "# Clara v1.1.5\n[![Build Status](https://travis-ci.org/catchorg/Clara.svg?branch=master)](https://travis-ci.org/catchorg/"
  },
  {
    "path": "Roadmap.md",
    "chars": 2164,
    "preview": "# Roadmap\n\n## June 2019 Update\n\nPreviously this roadmap said, \"I'm not quite ready to throw development fully open to th"
  },
  {
    "path": "appveyor.yml",
    "chars": 1669,
    "preview": "version: \"{build}\"\n\nbranches:\n  except:\n    - /dev-travis.+/\n\nos:\n  - Visual Studio 2017\n  - Visual Studio 2015\n\nenviron"
  },
  {
    "path": "codecov.yml",
    "chars": 91,
    "preview": "codecov:\n  branch: master\n\ncoverage:\n  ignore:\n    - \"src/*\"\n    - \"third_party/catch.hpp\"\n"
  },
  {
    "path": "docs/release-notes.md",
    "chars": 371,
    "preview": "<a id=\"top\"></a>\n\n# 1.1.3\n\n## Improvements\n* `Args` now take arguments as `int argc, char const * const * argv`.\n  * Thi"
  },
  {
    "path": "include/clara.hpp",
    "chars": 32286,
    "preview": "// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.\n//\n// Distributed under the Boost Software License, Version 1"
  },
  {
    "path": "include/clara_textflow.hpp",
    "chars": 11149,
    "preview": "// TextFlowCpp\n//\n// A single-header library for wrapping and laying out basic text, by Phil Nash\n//\n// Distributed unde"
  },
  {
    "path": "misc/CMakeLists.txt",
    "chars": 412,
    "preview": "cmake_minimum_required(VERSION 3.0)\n\nproject(ClaraCoverageHelper)\n\nadd_executable(CoverageHelper coverage-helper.cpp)\nse"
  },
  {
    "path": "misc/appveyorBuildConfigurationScript.bat",
    "chars": 425,
    "preview": "@REM  # In debug build, we want to prebuild memcheck redirecter\n@REM  # before running the tests\nif \"%CONFIGURATION%\"==\""
  },
  {
    "path": "misc/appveyorMergeCoverageScript.py",
    "chars": 305,
    "preview": "#!/usr/bin/env python2\n\nimport glob\nimport subprocess\n\nif __name__ == '__main__':\n    cov_files = list(glob.glob('cov-re"
  },
  {
    "path": "misc/appveyorTestRunScript.bat",
    "chars": 297,
    "preview": "cd Build\nif \"%CONFIGURATION%\"==\"Debug\" (\n  ctest -j 2 -C %CONFIGURATION% -D ExperimentalMemCheck\n  python ..\\misc\\appvey"
  },
  {
    "path": "misc/coverage-helper.cpp",
    "chars": 3174,
    "preview": "#include <algorithm>\n#include <array>\n#include <cassert>\n#include <cctype>\n#include <fstream>\n#include <iostream>\n#inclu"
  },
  {
    "path": "misc/installOpenCppCoverage.ps1",
    "chars": 1019,
    "preview": "# Downloads are done from the oficial github release page links\n$downloadUrl = \"https://github.com/OpenCppCoverage/OpenC"
  },
  {
    "path": "scripts/embed.py",
    "chars": 2344,
    "preview": "import re\n\npreprocessorRe = re.compile( r'\\s*#.*' )\n\nfdefineRe = re.compile( r'\\s*#\\s*define\\s*(\\S*)\\s*\\(' ) # #defines "
  },
  {
    "path": "scripts/embedTextFlow.py",
    "chars": 699,
    "preview": "#!/usr/bin/env python3\n\n# Execute this script any time you import a new copy of textflow into the third_party area\nimpor"
  },
  {
    "path": "scripts/release.py",
    "chars": 4278,
    "preview": "#!/usr/bin/env python\n\nfrom __future__ import print_function\nimport os\nimport sys\nimport re\n\nrootPath = os.path.dirname("
  },
  {
    "path": "scripts/stitch.py",
    "chars": 7612,
    "preview": "#!/usr/bin/env python\n\n# This is an initial cut of a general header stitching script.\n# It is currently hard-coded to wo"
  },
  {
    "path": "single_include/clara.hpp",
    "chars": 43451,
    "preview": "// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.\n//\n// Distributed under the Boost Software License, Version 1"
  },
  {
    "path": "src/ClaraTests.cpp",
    "chars": 18069,
    "preview": "#include \"clara.hpp\"\n\n#include \"catch.hpp\"\n\n#include <iostream>\n\nusing namespace clara;\n\nnamespace Catch {\ntemplate<>\nst"
  },
  {
    "path": "src/main.cpp",
    "chars": 47,
    "preview": "#define CATCH_CONFIG_MAIN\n#include \"catch.hpp\"\n"
  },
  {
    "path": "third_party/TextFlow.hpp",
    "chars": 11094,
    "preview": "// TextFlowCpp\n//\n// A single-header library for wrapping and laying out basic text, by Phil Nash\n//\n// Distributed unde"
  },
  {
    "path": "third_party/catch.hpp",
    "chars": 432556,
    "preview": "/*\n *  Catch v2.1.0\n *  Generated: 2018-01-10 13:51:15.378034\n *  ------------------------------------------------------"
  }
]

About this extraction

This page contains the full source code of the philsquared/Clara GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 32 files (601.8 KB), approximately 140.1k tokens, and a symbol index with 1460 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!