diff options
author | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
---|---|---|
committer | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
commit | e0c6872cf40896c7be36b11dcc744620f10adf1d (patch) | |
tree | 60335e10d2f4354b0674ec22d7b53f0f8abee672 /dviware/dvisvgm/libs/variant |
Initial commit
Diffstat (limited to 'dviware/dvisvgm/libs/variant')
-rw-r--r-- | dviware/dvisvgm/libs/variant/LICENSE.md | 23 | ||||
-rw-r--r-- | dviware/dvisvgm/libs/variant/Makefile.am | 4 | ||||
-rw-r--r-- | dviware/dvisvgm/libs/variant/Makefile.in | 555 | ||||
-rw-r--r-- | dviware/dvisvgm/libs/variant/include/mpark/variant.hpp | 2813 |
4 files changed, 3395 insertions, 0 deletions
diff --git a/dviware/dvisvgm/libs/variant/LICENSE.md b/dviware/dvisvgm/libs/variant/LICENSE.md new file mode 100644 index 0000000000..36b7cd93cd --- /dev/null +++ b/dviware/dvisvgm/libs/variant/LICENSE.md @@ -0,0 +1,23 @@ +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. diff --git a/dviware/dvisvgm/libs/variant/Makefile.am b/dviware/dvisvgm/libs/variant/Makefile.am new file mode 100644 index 0000000000..259818b960 --- /dev/null +++ b/dviware/dvisvgm/libs/variant/Makefile.am @@ -0,0 +1,4 @@ +noinst_HEADERS = \ + include/mpark/variant.hpp + +EXTRA_DIST = LICENSE.md diff --git a/dviware/dvisvgm/libs/variant/Makefile.in b/dviware/dvisvgm/libs/variant/Makefile.in new file mode 100644 index 0000000000..525c922b51 --- /dev/null +++ b/dviware/dvisvgm/libs/variant/Makefile.in @@ -0,0 +1,555 @@ +# Makefile.in generated by automake 1.16.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2018 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = { \ + if test -z '$(MAKELEVEL)'; then \ + false; \ + elif test -n '$(MAKE_HOST)'; then \ + true; \ + elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ + true; \ + else \ + false; \ + fi; \ +} +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +target_triplet = @target@ +subdir = libs/variant +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_compile_flag.m4 \ + $(top_srcdir)/m4/ax_code_coverage.m4 \ + $(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +DIST_COMMON = $(srcdir)/Makefile.am $(noinst_HEADERS) \ + $(am__DIST_COMMON) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +SOURCES = +DIST_SOURCES = +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +HEADERS = $(noinst_HEADERS) +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +am__DIST_COMMON = $(srcdir)/Makefile.in +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_CPPFLAGS = @AM_CPPFLAGS@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AM_LDFLAGS = @AM_LDFLAGS@ +AR = @AR@ +ASCIIDOC = @ASCIIDOC@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +BROTLI_CFLAGS = @BROTLI_CFLAGS@ +BROTLI_LIBS = @BROTLI_LIBS@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CODE_COVERAGE_CFLAGS = @CODE_COVERAGE_CFLAGS@ +CODE_COVERAGE_CPPFLAGS = @CODE_COVERAGE_CPPFLAGS@ +CODE_COVERAGE_CXXFLAGS = @CODE_COVERAGE_CXXFLAGS@ +CODE_COVERAGE_ENABLED = @CODE_COVERAGE_ENABLED@ +CODE_COVERAGE_LDFLAGS = @CODE_COVERAGE_LDFLAGS@ +CODE_COVERAGE_LIBS = @CODE_COVERAGE_LIBS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DATE = @DATE@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +FREETYPE_CFLAGS = @FREETYPE_CFLAGS@ +FREETYPE_LIBS = @FREETYPE_LIBS@ +GCOV = @GCOV@ +GENHTML = @GENHTML@ +GREP = @GREP@ +HAVE_CXX11 = @HAVE_CXX11@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +KPSE_CFLAGS = @KPSE_CFLAGS@ +KPSE_LIBS = @KPSE_LIBS@ +LCOV = @LCOV@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBCRYPTO_CFLAGS = @LIBCRYPTO_CFLAGS@ +LIBCRYPTO_LIBS = @LIBCRYPTO_LIBS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PKG_CONFIG = @PKG_CONFIG@ +PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ +PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +TTFAUTOHINT_CFLAGS = @TTFAUTOHINT_CFLAGS@ +TTFAUTOHINT_LIBS = @TTFAUTOHINT_LIBS@ +VERSION = @VERSION@ +WOFF2_CFLAGS = @WOFF2_CFLAGS@ +WOFF2_LIBS = @WOFF2_LIBS@ +XMLTO = @XMLTO@ +XSLTPROC = @XSLTPROC@ +ZLIB_CFLAGS = @ZLIB_CFLAGS@ +ZLIB_LIBS = @ZLIB_LIBS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +dvisvgm_srcdir = @dvisvgm_srcdir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target = @target@ +target_alias = @target_alias@ +target_cpu = @target_cpu@ +target_os = @target_os@ +target_vendor = @target_vendor@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +noinst_HEADERS = \ + include/mpark/variant.hpp + +EXTRA_DIST = LICENSE.md +all: all-am + +.SUFFIXES: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign libs/variant/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign libs/variant/Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) distdir-am + +distdir-am: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(HEADERS) +installdirs: +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libtool cscopelist-am ctags ctags-am distclean \ + distclean-generic distclean-libtool distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \ + uninstall-am + +.PRECIOUS: Makefile + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/dviware/dvisvgm/libs/variant/include/mpark/variant.hpp b/dviware/dvisvgm/libs/variant/include/mpark/variant.hpp new file mode 100644 index 0000000000..990a44cbab --- /dev/null +++ b/dviware/dvisvgm/libs/variant/include/mpark/variant.hpp @@ -0,0 +1,2813 @@ +// MPark.Variant +// +// Copyright Michael Park, 2015-2017 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +#ifndef MPARK_VARIANT_HPP +#define MPARK_VARIANT_HPP + +/* + variant synopsis + +namespace std { + + // 20.7.2, class template variant + template <class... Types> + class variant { + public: + + // 20.7.2.1, constructors + constexpr variant() noexcept(see below); + variant(const variant&); + variant(variant&&) noexcept(see below); + + template <class T> constexpr variant(T&&) noexcept(see below); + + template <class T, class... Args> + constexpr explicit variant(in_place_type_t<T>, Args&&...); + + template <class T, class U, class... Args> + constexpr explicit variant( + in_place_type_t<T>, initializer_list<U>, Args&&...); + + template <size_t I, class... Args> + constexpr explicit variant(in_place_index_t<I>, Args&&...); + + template <size_t I, class U, class... Args> + constexpr explicit variant( + in_place_index_t<I>, initializer_list<U>, Args&&...); + + // 20.7.2.2, destructor + ~variant(); + + // 20.7.2.3, assignment + variant& operator=(const variant&); + variant& operator=(variant&&) noexcept(see below); + + template <class T> variant& operator=(T&&) noexcept(see below); + + // 20.7.2.4, modifiers + template <class T, class... Args> + T& emplace(Args&&...); + + template <class T, class U, class... Args> + T& emplace(initializer_list<U>, Args&&...); + + template <size_t I, class... Args> + variant_alternative<I, variant>& emplace(Args&&...); + + template <size_t I, class U, class... Args> + variant_alternative<I, variant>& emplace(initializer_list<U>, Args&&...); + + // 20.7.2.5, value status + constexpr bool valueless_by_exception() const noexcept; + constexpr size_t index() const noexcept; + + // 20.7.2.6, swap + void swap(variant&) noexcept(see below); + }; + + // 20.7.3, variant helper classes + template <class T> struct variant_size; // undefined + + template <class T> + constexpr size_t variant_size_v = variant_size<T>::value; + + template <class T> struct variant_size<const T>; + template <class T> struct variant_size<volatile T>; + template <class T> struct variant_size<const volatile T>; + + template <class... Types> + struct variant_size<variant<Types...>>; + + template <size_t I, class T> struct variant_alternative; // undefined + + template <size_t I, class T> + using variant_alternative_t = typename variant_alternative<I, T>::type; + + template <size_t I, class T> struct variant_alternative<I, const T>; + template <size_t I, class T> struct variant_alternative<I, volatile T>; + template <size_t I, class T> struct variant_alternative<I, const volatile T>; + + template <size_t I, class... Types> + struct variant_alternative<I, variant<Types...>>; + + constexpr size_t variant_npos = -1; + + // 20.7.4, value access + template <class T, class... Types> + constexpr bool holds_alternative(const variant<Types...>&) noexcept; + + template <size_t I, class... Types> + constexpr variant_alternative_t<I, variant<Types...>>& + get(variant<Types...>&); + + template <size_t I, class... Types> + constexpr variant_alternative_t<I, variant<Types...>>&& + get(variant<Types...>&&); + + template <size_t I, class... Types> + constexpr variant_alternative_t<I, variant<Types...>> const& + get(const variant<Types...>&); + + template <size_t I, class... Types> + constexpr variant_alternative_t<I, variant<Types...>> const&& + get(const variant<Types...>&&); + + template <class T, class... Types> + constexpr T& get(variant<Types...>&); + + template <class T, class... Types> + constexpr T&& get(variant<Types...>&&); + + template <class T, class... Types> + constexpr const T& get(const variant<Types...>&); + + template <class T, class... Types> + constexpr const T&& get(const variant<Types...>&&); + + template <size_t I, class... Types> + constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>> + get_if(variant<Types...>*) noexcept; + + template <size_t I, class... Types> + constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>> + get_if(const variant<Types...>*) noexcept; + + template <class T, class... Types> + constexpr add_pointer_t<T> + get_if(variant<Types...>*) noexcept; + + template <class T, class... Types> + constexpr add_pointer_t<const T> + get_if(const variant<Types...>*) noexcept; + + // 20.7.5, relational operators + template <class... Types> + constexpr bool operator==(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator<(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator>(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&); + + // 20.7.6, visitation + template <class Visitor, class... Variants> + constexpr see below visit(Visitor&&, Variants&&...); + + // 20.7.7, class monostate + struct monostate; + + // 20.7.8, monostate relational operators + constexpr bool operator<(monostate, monostate) noexcept; + constexpr bool operator>(monostate, monostate) noexcept; + constexpr bool operator<=(monostate, monostate) noexcept; + constexpr bool operator>=(monostate, monostate) noexcept; + constexpr bool operator==(monostate, monostate) noexcept; + constexpr bool operator!=(monostate, monostate) noexcept; + + // 20.7.9, specialized algorithms + template <class... Types> + void swap(variant<Types...>&, variant<Types...>&) noexcept(see below); + + // 20.7.10, class bad_variant_access + class bad_variant_access; + + // 20.7.11, hash support + template <class T> struct hash; + template <class... Types> struct hash<variant<Types...>>; + template <> struct hash<monostate>; + +} // namespace std + +*/ + +#include <cstddef> +#include <exception> +#include <functional> +#include <initializer_list> +#include <new> +#include <type_traits> +#include <utility> + +// MPark.Variant +// +// Copyright Michael Park, 2015-2017 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +#ifndef MPARK_CONFIG_HPP +#define MPARK_CONFIG_HPP + +// MSVC 2015 Update 3. +#if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024210) +#error "MPark.Variant requires C++11 support." +#endif + +#ifndef __has_attribute +#define __has_attribute(x) 0 +#endif + +#ifndef __has_builtin +#define __has_builtin(x) 0 +#endif + +#ifndef __has_include +#define __has_include(x) 0 +#endif + +#ifndef __has_feature +#define __has_feature(x) 0 +#endif + +#if __has_attribute(always_inline) || defined(__GNUC__) +#define MPARK_ALWAYS_INLINE __attribute__((__always_inline__)) inline +#elif defined(_MSC_VER) +#define MPARK_ALWAYS_INLINE __forceinline +#else +#define MPARK_ALWAYS_INLINE inline +#endif + +#if __has_builtin(__builtin_addressof) || \ + (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER) +#define MPARK_BUILTIN_ADDRESSOF +#endif + +#if __has_builtin(__builtin_unreachable) || defined(__GNUC__) +#define MPARK_BUILTIN_UNREACHABLE __builtin_unreachable() +#elif defined(_MSC_VER) +#define MPARK_BUILTIN_UNREACHABLE __assume(false) +#else +#define MPARK_BUILTIN_UNREACHABLE +#endif + +#if __has_builtin(__type_pack_element) +#define MPARK_TYPE_PACK_ELEMENT +#endif + +#if defined(__cpp_constexpr) && __cpp_constexpr >= 200704 && \ + !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9) +#define MPARK_CPP11_CONSTEXPR +#endif + +#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304 +#define MPARK_CPP14_CONSTEXPR +#endif + +#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || \ + (defined(_MSC_VER) && defined(_CPPUNWIND)) +#define MPARK_EXCEPTIONS +#endif + +#if defined(__cpp_generic_lambdas) || defined(_MSC_VER) +#define MPARK_GENERIC_LAMBDAS +#endif + +#if defined(__cpp_lib_integer_sequence) +#define MPARK_INTEGER_SEQUENCE +#endif + +#if defined(__cpp_return_type_deduction) || defined(_MSC_VER) +#define MPARK_RETURN_TYPE_DEDUCTION +#endif + +#if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER) +#define MPARK_TRANSPARENT_OPERATORS +#endif + +#if defined(__cpp_variable_templates) || defined(_MSC_VER) +#define MPARK_VARIABLE_TEMPLATES +#endif + +#if !defined(__GLIBCXX__) || __has_include(<codecvt>) // >= libstdc++-5 +#define MPARK_TRIVIALITY_TYPE_TRAITS +#define MPARK_INCOMPLETE_TYPE_TRAITS +#endif + +#endif // MPARK_CONFIG_HPP + +// MPark.Variant +// +// Copyright Michael Park, 2015-2017 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +#ifndef MPARK_IN_PLACE_HPP +#define MPARK_IN_PLACE_HPP + +#include <cstddef> + + +namespace mpark { + + struct in_place_t { explicit in_place_t() = default; }; + + template <std::size_t I> + struct in_place_index_t { explicit in_place_index_t() = default; }; + + template <typename T> + struct in_place_type_t { explicit in_place_type_t() = default; }; + +#ifdef MPARK_VARIABLE_TEMPLATES + constexpr in_place_t in_place{}; + + template <std::size_t I> constexpr in_place_index_t<I> in_place_index{}; + + template <typename T> constexpr in_place_type_t<T> in_place_type{}; +#endif + +} // namespace mpark + +#endif // MPARK_IN_PLACE_HPP + +// MPark.Variant +// +// Copyright Michael Park, 2015-2017 +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) + +#ifndef MPARK_LIB_HPP +#define MPARK_LIB_HPP + +#include <memory> +#include <functional> +#include <type_traits> +#include <utility> + + +#define MPARK_RETURN(...) \ + noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { return __VA_ARGS__; } + +namespace mpark { + namespace lib { + template <typename T> + struct identity { using type = T; }; + + inline namespace cpp14 { + template <typename T, std::size_t N> + struct array { + constexpr const T &operator[](std::size_t index) const { + return data[index]; + } + + T data[N == 0 ? 1 : N]; + }; + + template <typename T> + using add_pointer_t = typename std::add_pointer<T>::type; + + template <typename... Ts> + using common_type_t = typename std::common_type<Ts...>::type; + + template <typename T> + using decay_t = typename std::decay<T>::type; + + template <bool B, typename T = void> + using enable_if_t = typename std::enable_if<B, T>::type; + + template <typename T> + using remove_const_t = typename std::remove_const<T>::type; + + template <typename T> + using remove_reference_t = typename std::remove_reference<T>::type; + + template <typename T> + inline constexpr T &&forward(remove_reference_t<T> &t) noexcept { + return static_cast<T &&>(t); + } + + template <typename T> + inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept { + static_assert(!std::is_lvalue_reference<T>::value, + "can not forward an rvalue as an lvalue"); + return static_cast<T &&>(t); + } + + template <typename T> + inline constexpr remove_reference_t<T> &&move(T &&t) noexcept { + return static_cast<remove_reference_t<T> &&>(t); + } + +#ifdef MPARK_INTEGER_SEQUENCE + using std::integer_sequence; + using std::index_sequence; + using std::make_index_sequence; + using std::index_sequence_for; +#else + template <typename T, T... Is> + struct integer_sequence { + using value_type = T; + static constexpr std::size_t size() noexcept { return sizeof...(Is); } + }; + + template <std::size_t... Is> + using index_sequence = integer_sequence<std::size_t, Is...>; + + template <typename Lhs, typename Rhs> + struct make_index_sequence_concat; + + template <std::size_t... Lhs, std::size_t... Rhs> + struct make_index_sequence_concat<index_sequence<Lhs...>, + index_sequence<Rhs...>> + : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {}; + + template <std::size_t N> + struct make_index_sequence_impl; + + template <std::size_t N> + using make_index_sequence = typename make_index_sequence_impl<N>::type; + + template <std::size_t N> + struct make_index_sequence_impl + : make_index_sequence_concat<make_index_sequence<N / 2>, + make_index_sequence<N - (N / 2)>> {}; + + template <> + struct make_index_sequence_impl<0> : identity<index_sequence<>> {}; + + template <> + struct make_index_sequence_impl<1> : identity<index_sequence<0>> {}; + + template <typename... Ts> + using index_sequence_for = make_index_sequence<sizeof...(Ts)>; +#endif + + // <functional> +#ifdef MPARK_TRANSPARENT_OPERATORS + using equal_to = std::equal_to<>; +#else + struct equal_to { + template <typename Lhs, typename Rhs> + inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const + MPARK_RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs)) + }; +#endif + +#ifdef MPARK_TRANSPARENT_OPERATORS + using not_equal_to = std::not_equal_to<>; +#else + struct not_equal_to { + template <typename Lhs, typename Rhs> + inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const + MPARK_RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs)) + }; +#endif + +#ifdef MPARK_TRANSPARENT_OPERATORS + using less = std::less<>; +#else + struct less { + template <typename Lhs, typename Rhs> + inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const + MPARK_RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs)) + }; +#endif + +#ifdef MPARK_TRANSPARENT_OPERATORS + using greater = std::greater<>; +#else + struct greater { + template <typename Lhs, typename Rhs> + inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const + MPARK_RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs)) + }; +#endif + +#ifdef MPARK_TRANSPARENT_OPERATORS + using less_equal = std::less_equal<>; +#else + struct less_equal { + template <typename Lhs, typename Rhs> + inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const + MPARK_RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs)) + }; +#endif + +#ifdef MPARK_TRANSPARENT_OPERATORS + using greater_equal = std::greater_equal<>; +#else + struct greater_equal { + template <typename Lhs, typename Rhs> + inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const + MPARK_RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs)) + }; +#endif + } // namespace cpp14 + + inline namespace cpp17 { + + // <type_traits> + template <bool B> + using bool_constant = std::integral_constant<bool, B>; + + template <typename...> + struct voider : identity<void> {}; + + template <typename... Ts> + using void_t = typename voider<Ts...>::type; + + namespace detail { + namespace swappable { + + using std::swap; + + template <typename T> + struct is_swappable { + private: + template <typename U, + typename = decltype(swap(std::declval<U &>(), + std::declval<U &>()))> + inline static std::true_type test(int); + + template <typename U> + inline static std::false_type test(...); + + public: + static constexpr bool value = decltype(test<T>(0))::value; + }; + + template <bool IsSwappable, typename T> + struct is_nothrow_swappable { + static constexpr bool value = + noexcept(swap(std::declval<T &>(), std::declval<T &>())); + }; + + template <typename T> + struct is_nothrow_swappable<false, T> : std::false_type {}; + + } // namespace swappable + } // namespace detail + + using detail::swappable::is_swappable; + + template <typename T> + using is_nothrow_swappable = + detail::swappable::is_nothrow_swappable<is_swappable<T>::value, T>; + + // <functional> + namespace detail { + + template <typename T> + struct is_reference_wrapper : std::false_type {}; + + template <typename T> + struct is_reference_wrapper<std::reference_wrapper<T>> + : std::true_type {}; + + template <bool, int> + struct Invoke; + + template <> + struct Invoke<true /* pmf */, 0 /* is_base_of */> { + template <typename R, typename T, typename Arg, typename... Args> + inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args) + MPARK_RETURN((lib::forward<Arg>(arg).*pmf)(lib::forward<Args>(args)...)) + }; + + template <> + struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> { + template <typename R, typename T, typename Arg, typename... Args> + inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args) + MPARK_RETURN((lib::forward<Arg>(arg).get().*pmf)(lib::forward<Args>(args)...)) + }; + + template <> + struct Invoke<true /* pmf */, 2 /* otherwise */> { + template <typename R, typename T, typename Arg, typename... Args> + inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args) + MPARK_RETURN(((*lib::forward<Arg>(arg)).*pmf)(lib::forward<Args>(args)...)) + }; + + template <> + struct Invoke<false /* pmo */, 0 /* is_base_of */> { + template <typename R, typename T, typename Arg> + inline static constexpr auto invoke(R T::*pmo, Arg &&arg) + MPARK_RETURN(lib::forward<Arg>(arg).*pmo) + }; + + template <> + struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> { + template <typename R, typename T, typename Arg> + inline static constexpr auto invoke(R T::*pmo, Arg &&arg) + MPARK_RETURN(lib::forward<Arg>(arg).get().*pmo) + }; + + template <> + struct Invoke<false /* pmo */, 2 /* otherwise */> { + template <typename R, typename T, typename Arg> + inline static constexpr auto invoke(R T::*pmo, Arg &&arg) + MPARK_RETURN((*lib::forward<Arg>(arg)).*pmo) + }; + + template <typename R, typename T, typename Arg, typename... Args> + inline constexpr auto invoke(R T::*f, Arg &&arg, Args &&... args) + MPARK_RETURN( + Invoke<std::is_function<R>::value, + (std::is_base_of<T, lib::decay_t<Arg>>::value + ? 0 + : is_reference_wrapper<lib::decay_t<Arg>>::value + ? 1 + : 2)>::invoke(f, + lib::forward<Arg>(arg), + lib::forward<Args>(args)...)) + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4100) +#endif + template <typename F, typename... Args> + inline constexpr auto invoke(F &&f, Args &&... args) + MPARK_RETURN(lib::forward<F>(f)(lib::forward<Args>(args)...)) +#ifdef _MSC_VER +#pragma warning(pop) +#endif + } // namespace detail + + template <typename F, typename... Args> + inline constexpr auto invoke(F &&f, Args &&... args) + MPARK_RETURN(detail::invoke(lib::forward<F>(f), + lib::forward<Args>(args)...)) + + namespace detail { + + template <typename Void, typename, typename...> + struct invoke_result {}; + + template <typename F, typename... Args> + struct invoke_result<void_t<decltype(lib::invoke( + std::declval<F>(), std::declval<Args>()...))>, + F, + Args...> + : identity<decltype( + lib::invoke(std::declval<F>(), std::declval<Args>()...))> {}; + + } // namespace detail + + template <typename F, typename... Args> + using invoke_result = detail::invoke_result<void, F, Args...>; + + template <typename F, typename... Args> + using invoke_result_t = typename invoke_result<F, Args...>::type; + + namespace detail { + + template <typename Void, typename, typename...> + struct is_invocable : std::false_type {}; + + template <typename F, typename... Args> + struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...> + : std::true_type {}; + + template <typename Void, typename, typename, typename...> + struct is_invocable_r : std::false_type {}; + + template <typename R, typename F, typename... Args> + struct is_invocable_r<void_t<invoke_result_t<F, Args...>>, + R, + F, + Args...> + : std::is_convertible<invoke_result_t<F, Args...>, R> {}; + + } // namespace detail + + template <typename F, typename... Args> + using is_invocable = detail::is_invocable<void, F, Args...>; + + template <typename R, typename F, typename... Args> + using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>; + + namespace detail { + + template <bool Invocable, typename F, typename... Args> + struct is_nothrow_invocable { + static constexpr bool value = + noexcept(lib::invoke(std::declval<F>(), std::declval<Args>()...)); + }; + + template <typename F, typename... Args> + struct is_nothrow_invocable<false, F, Args...> : std::false_type {}; + + template <bool Invocable, typename R, typename F, typename... Args> + struct is_nothrow_invocable_r { + private: + inline static R impl() { + return lib::invoke(std::declval<F>(), std::declval<Args>()...); + } + + public: + static constexpr bool value = noexcept(impl()); + }; + + template <typename R, typename F, typename... Args> + struct is_nothrow_invocable_r<false, R, F, Args...> : std::false_type {}; + + } // namespace detail + + template <typename F, typename... Args> + using is_nothrow_invocable = detail:: + is_nothrow_invocable<is_invocable<F, Args...>::value, F, Args...>; + + template <typename R, typename F, typename... Args> + using is_nothrow_invocable_r = + detail::is_nothrow_invocable_r<is_invocable_r<R, F, Args...>::value, + R, + F, + Args...>; + + // <memory> +#ifdef MPARK_BUILTIN_ADDRESSOF + template <typename T> + inline constexpr T *addressof(T &arg) noexcept { + return __builtin_addressof(arg); + } +#else + namespace detail { + + namespace has_addressof_impl { + + struct fail; + + template <typename T> + inline fail operator&(T &&); + + template <typename T> + inline static constexpr bool impl() { + return (std::is_class<T>::value || std::is_union<T>::value) && + !std::is_same<decltype(&std::declval<T &>()), fail>::value; + } + + } // namespace has_addressof_impl + + template <typename T> + using has_addressof = bool_constant<has_addressof_impl::impl<T>()>; + + template <typename T> + inline constexpr T *addressof(T &arg, std::true_type) noexcept { + return std::addressof(arg); + } + + template <typename T> + inline constexpr T *addressof(T &arg, std::false_type) noexcept { + return &arg; + } + + } // namespace detail + + template <typename T> + inline constexpr T *addressof(T &arg) noexcept { + return detail::addressof(arg, detail::has_addressof<T>{}); + } +#endif + + template <typename T> + inline constexpr T *addressof(const T &&) = delete; + + } // namespace cpp17 + + template <typename T> + struct remove_all_extents : identity<T> {}; + + template <typename T, std::size_t N> + struct remove_all_extents<array<T, N>> : remove_all_extents<T> {}; + + template <typename T> + using remove_all_extents_t = typename remove_all_extents<T>::type; + + template <std::size_t N> + using size_constant = std::integral_constant<std::size_t, N>; + + template <std::size_t I, typename T> + struct indexed_type : size_constant<I> { using type = T; }; + + template <bool... Bs> + using all = std::is_same<integer_sequence<bool, true, Bs...>, + integer_sequence<bool, Bs..., true>>; + +#ifdef MPARK_TYPE_PACK_ELEMENT + template <std::size_t I, typename... Ts> + using type_pack_element_t = __type_pack_element<I, Ts...>; +#else + template <std::size_t I, typename... Ts> + struct type_pack_element_impl { + private: + template <typename> + struct set; + + template <std::size_t... Is> + struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {}; + + template <typename T> + inline static std::enable_if<true, T> impl(indexed_type<I, T>); + + inline static std::enable_if<false> impl(...); + + public: + using type = decltype(impl(set<index_sequence_for<Ts...>>{})); + }; + + template <std::size_t I, typename... Ts> + using type_pack_element = typename type_pack_element_impl<I, Ts...>::type; + + template <std::size_t I, typename... Ts> + using type_pack_element_t = typename type_pack_element<I, Ts...>::type; +#endif + +#ifdef MPARK_TRIVIALITY_TYPE_TRAITS + using std::is_trivially_copy_constructible; + using std::is_trivially_move_constructible; + using std::is_trivially_copy_assignable; + using std::is_trivially_move_assignable; +#else + template <typename T> + struct is_trivially_copy_constructible + : bool_constant< + std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {}; + + template <typename T> + struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {}; + + template <typename T> + struct is_trivially_copy_assignable + : bool_constant< + std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {}; + + template <typename T> + struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {}; +#endif + + template <typename T, bool> + struct dependent_type : T {}; + + template <typename Is, std::size_t J> + struct push_back; + + template <typename Is, std::size_t J> + using push_back_t = typename push_back<Is, J>::type; + + template <std::size_t... Is, std::size_t J> + struct push_back<index_sequence<Is...>, J> { + using type = index_sequence<Is..., J>; + }; + + } // namespace lib +} // namespace mpark + +#undef MPARK_RETURN + +#endif // MPARK_LIB_HPP + + +namespace mpark { + +#ifdef MPARK_RETURN_TYPE_DEDUCTION + +#define AUTO auto +#define AUTO_RETURN(...) { return __VA_ARGS__; } + +#define AUTO_REFREF auto && +#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; } + +#define DECLTYPE_AUTO decltype(auto) +#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; } + +#else + +#define AUTO auto +#define AUTO_RETURN(...) \ + -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; } + +#define AUTO_REFREF auto +#define AUTO_REFREF_RETURN(...) \ + -> decltype((__VA_ARGS__)) { \ + static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \ + return __VA_ARGS__; \ + } + +#define DECLTYPE_AUTO auto +#define DECLTYPE_AUTO_RETURN(...) \ + -> decltype(__VA_ARGS__) { return __VA_ARGS__; } + +#endif + + class bad_variant_access : public std::exception { + public: + virtual const char *what() const noexcept override { return "bad_variant_access"; } + }; + + [[noreturn]] inline void throw_bad_variant_access() { +#ifdef MPARK_EXCEPTIONS + throw bad_variant_access{}; +#else + std::terminate(); + MPARK_BUILTIN_UNREACHABLE; +#endif + } + + template <typename... Ts> + class variant; + + template <typename T> + struct variant_size; + +#ifdef MPARK_VARIABLE_TEMPLATES + template <typename T> + constexpr std::size_t variant_size_v = variant_size<T>::value; +#endif + + template <typename T> + struct variant_size<const T> : variant_size<T> {}; + + template <typename T> + struct variant_size<volatile T> : variant_size<T> {}; + + template <typename T> + struct variant_size<const volatile T> : variant_size<T> {}; + + template <typename... Ts> + struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {}; + + template <std::size_t I, typename T> + struct variant_alternative; + + template <std::size_t I, typename T> + using variant_alternative_t = typename variant_alternative<I, T>::type; + + template <std::size_t I, typename T> + struct variant_alternative<I, const T> + : std::add_const<variant_alternative_t<I, T>> {}; + + template <std::size_t I, typename T> + struct variant_alternative<I, volatile T> + : std::add_volatile<variant_alternative_t<I, T>> {}; + + template <std::size_t I, typename T> + struct variant_alternative<I, const volatile T> + : std::add_cv<variant_alternative_t<I, T>> {}; + + template <std::size_t I, typename... Ts> + struct variant_alternative<I, variant<Ts...>> { + static_assert(I < sizeof...(Ts), + "index out of bounds in `std::variant_alternative<>`"); + using type = lib::type_pack_element_t<I, Ts...>; + }; + + constexpr std::size_t variant_npos = static_cast<std::size_t>(-1); + + namespace detail { + + constexpr std::size_t not_found = static_cast<std::size_t>(-1); + constexpr std::size_t ambiguous = static_cast<std::size_t>(-2); + +#ifdef MPARK_CPP14_CONSTEXPR + template <typename T, typename... Ts> + inline constexpr std::size_t find_index() { + constexpr lib::array<bool, sizeof...(Ts)> matches = { + {std::is_same<T, Ts>::value...} + }; + std::size_t result = not_found; + for (std::size_t i = 0; i < sizeof...(Ts); ++i) { + if (matches[i]) { + if (result != not_found) { + return ambiguous; + } + result = i; + } + } + return result; + } +#else + inline constexpr std::size_t find_index_impl(std::size_t result, + std::size_t) { + return result; + } + + template <typename... Bs> + inline constexpr std::size_t find_index_impl(std::size_t result, + std::size_t idx, + bool b, + Bs... bs) { + return b ? (result != not_found ? ambiguous + : find_index_impl(idx, idx + 1, bs...)) + : find_index_impl(result, idx + 1, bs...); + } + + template <typename T, typename... Ts> + inline constexpr std::size_t find_index() { + return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...); + } +#endif + + template <std::size_t I> + using find_index_sfinae_impl = + lib::enable_if_t<I != not_found && I != ambiguous, + lib::size_constant<I>>; + + template <typename T, typename... Ts> + using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>; + + template <std::size_t I> + struct find_index_checked_impl : lib::size_constant<I> { + static_assert(I != not_found, "the specified type is not found."); + static_assert(I != ambiguous, "the specified type is ambiguous."); + }; + + template <typename T, typename... Ts> + using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>; + + struct valueless_t {}; + + enum class Trait { TriviallyAvailable, Available, Unavailable }; + + template <typename T, + template <typename> class IsTriviallyAvailable, + template <typename> class IsAvailable> + inline constexpr Trait trait() { + return IsTriviallyAvailable<T>::value + ? Trait::TriviallyAvailable + : IsAvailable<T>::value ? Trait::Available + : Trait::Unavailable; + } + +#ifdef MPARK_CPP14_CONSTEXPR + template <typename... Traits> + inline constexpr Trait common_trait(Traits... traits_) { + Trait result = Trait::TriviallyAvailable; + lib::array<Trait, sizeof...(Traits)> traits = {{traits_...}}; + for (std::size_t i = 0; i < sizeof...(Traits); ++i) { + Trait t = traits[i]; + if (static_cast<int>(t) > static_cast<int>(result)) { + result = t; + } + } + return result; + } +#else + inline constexpr Trait common_trait_impl(Trait result) { return result; } + + template <typename... Traits> + inline constexpr Trait common_trait_impl(Trait result, + Trait t, + Traits... ts) { + return static_cast<int>(t) > static_cast<int>(result) + ? common_trait_impl(t, ts...) + : common_trait_impl(result, ts...); + } + + template <typename... Traits> + inline constexpr Trait common_trait(Traits... ts) { + return common_trait_impl(Trait::TriviallyAvailable, ts...); + } +#endif + + template <typename... Ts> + struct traits { + static constexpr Trait copy_constructible_trait = + common_trait(trait<Ts, + lib::is_trivially_copy_constructible, + std::is_copy_constructible>()...); + + static constexpr Trait move_constructible_trait = + common_trait(trait<Ts, + lib::is_trivially_move_constructible, + std::is_move_constructible>()...); + + static constexpr Trait copy_assignable_trait = + common_trait(copy_constructible_trait, + trait<Ts, + lib::is_trivially_copy_assignable, + std::is_copy_assignable>()...); + + static constexpr Trait move_assignable_trait = + common_trait(move_constructible_trait, + trait<Ts, + lib::is_trivially_move_assignable, + std::is_move_assignable>()...); + + static constexpr Trait destructible_trait = + common_trait(trait<Ts, + std::is_trivially_destructible, + std::is_destructible>()...); + }; + + namespace access { + + struct recursive_union { +#ifdef MPARK_RETURN_TYPE_DEDUCTION + template <typename V> + inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) { + return lib::forward<V>(v).head_; + } + + template <typename V, std::size_t I> + inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) { + return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{}); + } +#else + template <std::size_t I, bool Dummy = true> + struct get_alt_impl { + template <typename V> + inline constexpr AUTO_REFREF operator()(V &&v) const + AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_)) + }; + + template <bool Dummy> + struct get_alt_impl<0, Dummy> { + template <typename V> + inline constexpr AUTO_REFREF operator()(V &&v) const + AUTO_REFREF_RETURN(lib::forward<V>(v).head_) + }; + + template <typename V, std::size_t I> + inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>) + AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v))) +#endif + }; + + struct base { + template <std::size_t I, typename V> + inline static constexpr AUTO_REFREF get_alt(V &&v) +#ifdef _MSC_VER + AUTO_REFREF_RETURN(recursive_union::get_alt( + lib::forward<V>(v).data_, in_place_index_t<I>{})) +#else + AUTO_REFREF_RETURN(recursive_union::get_alt( + data(lib::forward<V>(v)), in_place_index_t<I>{})) +#endif + }; + + struct variant { + template <std::size_t I, typename V> + inline static constexpr AUTO_REFREF get_alt(V &&v) + AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_)) + }; + + } // namespace access + + namespace visitation { + +#if defined(MPARK_CPP14_CONSTEXPR) && !defined(_MSC_VER) +#define MPARK_VARIANT_SWITCH_VISIT +#endif + + struct base { + template <typename Visitor, typename... Vs> + using dispatch_result_t = decltype( + lib::invoke(std::declval<Visitor>(), + access::base::get_alt<0>(std::declval<Vs>())...)); + + template <typename Expected> + struct expected { + template <typename Actual> + inline static constexpr bool but_got() { + return std::is_same<Expected, Actual>::value; + } + }; + + template <typename Expected, typename Actual> + struct visit_return_type_check { + static_assert( + expected<Expected>::template but_got<Actual>(), + "`visit` requires the visitor to have a single return type"); + + template <typename Visitor, typename... Alts> + inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor, + Alts &&... alts) + DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor), + lib::forward<Alts>(alts)...)) + }; + +#ifdef MPARK_VARIANT_SWITCH_VISIT + template <bool B, typename R, typename... ITs> + struct dispatcher; + + template <typename R, typename... ITs> + struct dispatcher<false, R, ITs...> { + template <std::size_t B, typename F, typename... Vs> + MPARK_ALWAYS_INLINE static constexpr R dispatch( + F &&, typename ITs::type &&..., Vs &&...) { + MPARK_BUILTIN_UNREACHABLE; + } + + template <std::size_t I, typename F, typename... Vs> + MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&, Vs &&...) { + MPARK_BUILTIN_UNREACHABLE; + } + + template <std::size_t B, typename F, typename... Vs> + MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t, + F &&, + Vs &&...) { + MPARK_BUILTIN_UNREACHABLE; + } + }; + + template <typename R, typename... ITs> + struct dispatcher<true, R, ITs...> { + template <std::size_t B, typename F> + MPARK_ALWAYS_INLINE static constexpr R dispatch( + F &&f, typename ITs::type &&... visited_vs) { + using Expected = R; + using Actual = decltype(lib::invoke( + lib::forward<F>(f), + access::base::get_alt<ITs::value>( + lib::forward<typename ITs::type>(visited_vs))...)); + return visit_return_type_check<Expected, Actual>::invoke( + lib::forward<F>(f), + access::base::get_alt<ITs::value>( + lib::forward<typename ITs::type>(visited_vs))...); + } + + template <std::size_t B, typename F, typename V, typename... Vs> + MPARK_ALWAYS_INLINE static constexpr R dispatch( + F &&f, typename ITs::type &&... visited_vs, V &&v, Vs &&... vs) { +#define MPARK_DISPATCH(I) \ + dispatcher<(I < lib::decay_t<V>::size()), \ + R, \ + ITs..., \ + lib::indexed_type<I, V>>:: \ + template dispatch<0>(lib::forward<F>(f), \ + lib::forward<typename ITs::type>(visited_vs)..., \ + lib::forward<V>(v), \ + lib::forward<Vs>(vs)...) + +#define MPARK_DEFAULT(I) \ + dispatcher<(I < lib::decay_t<V>::size()), R, ITs...>::template dispatch<I>( \ + lib::forward<F>(f), \ + lib::forward<typename ITs::type>(visited_vs)..., \ + lib::forward<V>(v), \ + lib::forward<Vs>(vs)...) + + switch (v.index()) { + case B + 0: return MPARK_DISPATCH(B + 0); + case B + 1: return MPARK_DISPATCH(B + 1); + case B + 2: return MPARK_DISPATCH(B + 2); + case B + 3: return MPARK_DISPATCH(B + 3); + case B + 4: return MPARK_DISPATCH(B + 4); + case B + 5: return MPARK_DISPATCH(B + 5); + case B + 6: return MPARK_DISPATCH(B + 6); + case B + 7: return MPARK_DISPATCH(B + 7); + case B + 8: return MPARK_DISPATCH(B + 8); + case B + 9: return MPARK_DISPATCH(B + 9); + case B + 10: return MPARK_DISPATCH(B + 10); + case B + 11: return MPARK_DISPATCH(B + 11); + case B + 12: return MPARK_DISPATCH(B + 12); + case B + 13: return MPARK_DISPATCH(B + 13); + case B + 14: return MPARK_DISPATCH(B + 14); + case B + 15: return MPARK_DISPATCH(B + 15); + case B + 16: return MPARK_DISPATCH(B + 16); + case B + 17: return MPARK_DISPATCH(B + 17); + case B + 18: return MPARK_DISPATCH(B + 18); + case B + 19: return MPARK_DISPATCH(B + 19); + case B + 20: return MPARK_DISPATCH(B + 20); + case B + 21: return MPARK_DISPATCH(B + 21); + case B + 22: return MPARK_DISPATCH(B + 22); + case B + 23: return MPARK_DISPATCH(B + 23); + case B + 24: return MPARK_DISPATCH(B + 24); + case B + 25: return MPARK_DISPATCH(B + 25); + case B + 26: return MPARK_DISPATCH(B + 26); + case B + 27: return MPARK_DISPATCH(B + 27); + case B + 28: return MPARK_DISPATCH(B + 28); + case B + 29: return MPARK_DISPATCH(B + 29); + case B + 30: return MPARK_DISPATCH(B + 30); + case B + 31: return MPARK_DISPATCH(B + 31); + default: return MPARK_DEFAULT(B + 32); + } + +#undef MPARK_DEFAULT +#undef MPARK_DISPATCH + } + + template <std::size_t I, typename F, typename... Vs> + MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&f, + Vs &&... vs) { + using Expected = R; + using Actual = decltype( + lib::invoke(lib::forward<F>(f), + access::base::get_alt<I>(lib::forward<Vs>(vs))...)); + return visit_return_type_check<Expected, Actual>::invoke( + lib::forward<F>(f), + access::base::get_alt<I>(lib::forward<Vs>(vs))...); + } + + template <std::size_t B, typename F, typename V, typename... Vs> + MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t index, + F &&f, + V &&v, + Vs &&... vs) { + static_assert(lib::all<(lib::decay_t<V>::size() == + lib::decay_t<Vs>::size())...>::value, + "all of the variants must be the same size."); +#define MPARK_DISPATCH_AT(I) \ + dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_case<I>( \ + lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...) + +#define MPARK_DEFAULT(I) \ + dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_at<I>( \ + index, lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...) + + switch (index) { + case B + 0: return MPARK_DISPATCH_AT(B + 0); + case B + 1: return MPARK_DISPATCH_AT(B + 1); + case B + 2: return MPARK_DISPATCH_AT(B + 2); + case B + 3: return MPARK_DISPATCH_AT(B + 3); + case B + 4: return MPARK_DISPATCH_AT(B + 4); + case B + 5: return MPARK_DISPATCH_AT(B + 5); + case B + 6: return MPARK_DISPATCH_AT(B + 6); + case B + 7: return MPARK_DISPATCH_AT(B + 7); + case B + 8: return MPARK_DISPATCH_AT(B + 8); + case B + 9: return MPARK_DISPATCH_AT(B + 9); + case B + 10: return MPARK_DISPATCH_AT(B + 10); + case B + 11: return MPARK_DISPATCH_AT(B + 11); + case B + 12: return MPARK_DISPATCH_AT(B + 12); + case B + 13: return MPARK_DISPATCH_AT(B + 13); + case B + 14: return MPARK_DISPATCH_AT(B + 14); + case B + 15: return MPARK_DISPATCH_AT(B + 15); + case B + 16: return MPARK_DISPATCH_AT(B + 16); + case B + 17: return MPARK_DISPATCH_AT(B + 17); + case B + 18: return MPARK_DISPATCH_AT(B + 18); + case B + 19: return MPARK_DISPATCH_AT(B + 19); + case B + 20: return MPARK_DISPATCH_AT(B + 20); + case B + 21: return MPARK_DISPATCH_AT(B + 21); + case B + 22: return MPARK_DISPATCH_AT(B + 22); + case B + 23: return MPARK_DISPATCH_AT(B + 23); + case B + 24: return MPARK_DISPATCH_AT(B + 24); + case B + 25: return MPARK_DISPATCH_AT(B + 25); + case B + 26: return MPARK_DISPATCH_AT(B + 26); + case B + 27: return MPARK_DISPATCH_AT(B + 27); + case B + 28: return MPARK_DISPATCH_AT(B + 28); + case B + 29: return MPARK_DISPATCH_AT(B + 29); + case B + 30: return MPARK_DISPATCH_AT(B + 30); + case B + 31: return MPARK_DISPATCH_AT(B + 31); + default: return MPARK_DEFAULT(B + 32); + } + +#undef MPARK_DEFAULT +#undef MPARK_DISPATCH_AT + } + }; +#else + template <typename T> + inline static constexpr const T &at(const T &elem) noexcept { + return elem; + } + + template <typename T, std::size_t N, typename... Is> + inline static constexpr const lib::remove_all_extents_t<T> &at( + const lib::array<T, N> &elems, std::size_t i, Is... is) noexcept { + return at(elems[i], is...); + } + + template <typename F, typename... Fs> + inline static constexpr lib::array<lib::decay_t<F>, sizeof...(Fs) + 1> + make_farray(F &&f, Fs &&... fs) { + return {{lib::forward<F>(f), lib::forward<Fs>(fs)...}}; + } + + template <typename F, typename... Vs> + struct make_fmatrix_impl { + + template <std::size_t... Is> + inline static constexpr dispatch_result_t<F, Vs...> dispatch( + F &&f, Vs &&... vs) { + using Expected = dispatch_result_t<F, Vs...>; + using Actual = decltype(lib::invoke( + lib::forward<F>(f), + access::base::get_alt<Is>(lib::forward<Vs>(vs))...)); + return visit_return_type_check<Expected, Actual>::invoke( + lib::forward<F>(f), + access::base::get_alt<Is>(lib::forward<Vs>(vs))...); + } + +#ifdef MPARK_RETURN_TYPE_DEDUCTION + template <std::size_t... Is> + inline static constexpr auto impl(lib::index_sequence<Is...>) { + return &dispatch<Is...>; + } + + template <typename Is, std::size_t... Js, typename... Ls> + inline static constexpr auto impl(Is, + lib::index_sequence<Js...>, + Ls... ls) { + return make_farray(impl(lib::push_back_t<Is, Js>{}, ls...)...); + } +#else + template <typename...> + struct impl; + + template <std::size_t... Is> + struct impl<lib::index_sequence<Is...>> { + inline constexpr AUTO operator()() const + AUTO_RETURN(&dispatch<Is...>) + }; + + template <typename Is, std::size_t... Js, typename... Ls> + struct impl<Is, lib::index_sequence<Js...>, Ls...> { + inline constexpr AUTO operator()() const + AUTO_RETURN( + make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...)) + }; +#endif + }; + +#ifdef MPARK_RETURN_TYPE_DEDUCTION + template <typename F, typename... Vs> + inline static constexpr auto make_fmatrix() { + return make_fmatrix_impl<F, Vs...>::impl( + lib::index_sequence<>{}, + lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...); + } +#else + template <typename F, typename... Vs> + inline static constexpr AUTO make_fmatrix() + AUTO_RETURN( + typename make_fmatrix_impl<F, Vs...>::template impl< + lib::index_sequence<>, + lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}()) +#endif + + template <typename F, typename... Vs> + struct make_fdiagonal_impl { + template <std::size_t I> + inline static constexpr dispatch_result_t<F, Vs...> dispatch( + F &&f, Vs &&... vs) { + using Expected = dispatch_result_t<F, Vs...>; + using Actual = decltype( + lib::invoke(lib::forward<F>(f), + access::base::get_alt<I>(lib::forward<Vs>(vs))...)); + return visit_return_type_check<Expected, Actual>::invoke( + lib::forward<F>(f), + access::base::get_alt<I>(lib::forward<Vs>(vs))...); + } + + template <std::size_t... Is> + inline static constexpr AUTO impl(lib::index_sequence<Is...>) + AUTO_RETURN(make_farray(&dispatch<Is>...)) + }; + + template <typename F, typename V, typename... Vs> + inline static constexpr auto make_fdiagonal() + -> decltype(make_fdiagonal_impl<F, V, Vs...>::impl( + lib::make_index_sequence<lib::decay_t<V>::size()>{})) { + static_assert(lib::all<(lib::decay_t<V>::size() == + lib::decay_t<Vs>::size())...>::value, + "all of the variants must be the same size."); + return make_fdiagonal_impl<F, V, Vs...>::impl( + lib::make_index_sequence<lib::decay_t<V>::size()>{}); + } +#endif + }; + +#if !defined(MPARK_VARIANT_SWITCH_VISIT) && \ + (!defined(_MSC_VER) || _MSC_VER >= 1910) + template <typename F, typename... Vs> + using fmatrix_t = decltype(base::make_fmatrix<F, Vs...>()); + + template <typename F, typename... Vs> + struct fmatrix { + static constexpr fmatrix_t<F, Vs...> value = + base::make_fmatrix<F, Vs...>(); + }; + + template <typename F, typename... Vs> + constexpr fmatrix_t<F, Vs...> fmatrix<F, Vs...>::value; + + template <typename F, typename... Vs> + using fdiagonal_t = decltype(base::make_fdiagonal<F, Vs...>()); + + template <typename F, typename... Vs> + struct fdiagonal { + static constexpr fdiagonal_t<F, Vs...> value = + base::make_fdiagonal<F, Vs...>(); + }; + + template <typename F, typename... Vs> + constexpr fdiagonal_t<F, Vs...> fdiagonal<F, Vs...>::value; +#endif + + struct alt { + template <typename Visitor, typename... Vs> + inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor, + Vs &&... vs) +#ifdef MPARK_VARIANT_SWITCH_VISIT + DECLTYPE_AUTO_RETURN( + base::dispatcher< + true, + base::dispatch_result_t<Visitor, + decltype(as_base( + lib::forward<Vs>(vs)))...>>:: + template dispatch<0>(lib::forward<Visitor>(visitor), + as_base(lib::forward<Vs>(vs))...)) +#elif !defined(_MSC_VER) || _MSC_VER >= 1910 + DECLTYPE_AUTO_RETURN(base::at( + fmatrix<Visitor &&, + decltype(as_base(lib::forward<Vs>(vs)))...>::value, + vs.index()...)(lib::forward<Visitor>(visitor), + as_base(lib::forward<Vs>(vs))...)) +#else + DECLTYPE_AUTO_RETURN(base::at( + base::make_fmatrix<Visitor &&, + decltype(as_base(lib::forward<Vs>(vs)))...>(), + vs.index()...)(lib::forward<Visitor>(visitor), + as_base(lib::forward<Vs>(vs))...)) +#endif + + template <typename Visitor, typename... Vs> + inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index, + Visitor &&visitor, + Vs &&... vs) +#ifdef MPARK_VARIANT_SWITCH_VISIT + DECLTYPE_AUTO_RETURN( + base::dispatcher< + true, + base::dispatch_result_t<Visitor, + decltype(as_base( + lib::forward<Vs>(vs)))...>>:: + template dispatch_at<0>(index, + lib::forward<Visitor>(visitor), + as_base(lib::forward<Vs>(vs))...)) +#elif !defined(_MSC_VER) || _MSC_VER >= 1910 + DECLTYPE_AUTO_RETURN(base::at( + fdiagonal<Visitor &&, + decltype(as_base(lib::forward<Vs>(vs)))...>::value, + index)(lib::forward<Visitor>(visitor), + as_base(lib::forward<Vs>(vs))...)) +#else + DECLTYPE_AUTO_RETURN(base::at( + base::make_fdiagonal<Visitor &&, + decltype(as_base(lib::forward<Vs>(vs)))...>(), + index)(lib::forward<Visitor>(visitor), + as_base(lib::forward<Vs>(vs))...)) +#endif + }; + + struct variant { + private: + template <typename Visitor> + struct visitor { + template <typename... Values> + inline static constexpr bool does_not_handle() { + return lib::is_invocable<Visitor, Values...>::value; + } + }; + + template <typename Visitor, typename... Values> + struct visit_exhaustiveness_check { + static_assert(visitor<Visitor>::template does_not_handle<Values...>(), + "`visit` requires the visitor to be exhaustive."); + + inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor, + Values &&... values) + DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor), + lib::forward<Values>(values)...)) + }; + + template <typename Visitor> + struct value_visitor { + Visitor &&visitor_; + + template <typename... Alts> + inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const + DECLTYPE_AUTO_RETURN( + visit_exhaustiveness_check< + Visitor, + decltype((lib::forward<Alts>(alts).value))...>:: + invoke(lib::forward<Visitor>(visitor_), + lib::forward<Alts>(alts).value...)) + }; + + template <typename Visitor> + inline static constexpr AUTO make_value_visitor(Visitor &&visitor) + AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)}) + + public: + template <typename Visitor, typename... Vs> + inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor, + Vs &&... vs) + DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward<Visitor>(visitor), + lib::forward<Vs>(vs).impl_...)) + + template <typename Visitor, typename... Vs> + inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index, + Visitor &&visitor, + Vs &&... vs) + DECLTYPE_AUTO_RETURN( + alt::visit_alt_at(index, + lib::forward<Visitor>(visitor), + lib::forward<Vs>(vs).impl_...)) + + template <typename Visitor, typename... Vs> + inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor, + Vs &&... vs) + DECLTYPE_AUTO_RETURN( + visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)), + lib::forward<Vs>(vs)...)) + + template <typename Visitor, typename... Vs> + inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index, + Visitor &&visitor, + Vs &&... vs) + DECLTYPE_AUTO_RETURN( + visit_alt_at(index, + make_value_visitor(lib::forward<Visitor>(visitor)), + lib::forward<Vs>(vs)...)) + }; + + } // namespace visitation + + template <std::size_t Index, typename T> + struct alt { + using value_type = T; + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4244) +#endif + template <typename... Args> + inline explicit constexpr alt(in_place_t, Args &&... args) + : value(lib::forward<Args>(args)...) {} +#ifdef _MSC_VER +#pragma warning(pop) +#endif + + T value; + }; + + template <Trait DestructibleTrait, std::size_t Index, typename... Ts> + union recursive_union; + + template <Trait DestructibleTrait, std::size_t Index> + union recursive_union<DestructibleTrait, Index> {}; + +#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor) \ + template <std::size_t Index, typename T, typename... Ts> \ + union recursive_union<destructible_trait, Index, T, Ts...> { \ + public: \ + inline explicit constexpr recursive_union(valueless_t) noexcept \ + : dummy_{} {} \ + \ + template <typename... Args> \ + inline explicit constexpr recursive_union(in_place_index_t<0>, \ + Args &&... args) \ + : head_(in_place_t{}, lib::forward<Args>(args)...) {} \ + \ + template <std::size_t I, typename... Args> \ + inline explicit constexpr recursive_union(in_place_index_t<I>, \ + Args &&... args) \ + : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \ + \ + recursive_union(const recursive_union &) = default; \ + recursive_union(recursive_union &&) = default; \ + \ + destructor \ + \ + recursive_union &operator=(const recursive_union &) = default; \ + recursive_union &operator=(recursive_union &&) = default; \ + \ + private: \ + char dummy_; \ + alt<Index, T> head_; \ + recursive_union<destructible_trait, Index + 1, Ts...> tail_; \ + \ + friend struct access::recursive_union; \ + } + + MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable, + ~recursive_union() = default;); + MPARK_VARIANT_RECURSIVE_UNION(Trait::Available, + ~recursive_union() {}); + MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable, + ~recursive_union() = delete;); + +#undef MPARK_VARIANT_RECURSIVE_UNION + + using index_t = unsigned int; + + template <Trait DestructibleTrait, typename... Ts> + class base { + public: + inline explicit constexpr base(valueless_t tag) noexcept + : data_(tag), index_(static_cast<index_t>(-1)) {} + + template <std::size_t I, typename... Args> + inline explicit constexpr base(in_place_index_t<I>, Args &&... args) + : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...), + index_(I) {} + + inline constexpr bool valueless_by_exception() const noexcept { + return index_ == static_cast<index_t>(-1); + } + + inline constexpr std::size_t index() const noexcept { + return valueless_by_exception() ? variant_npos : index_; + } + + protected: + using data_t = recursive_union<DestructibleTrait, 0, Ts...>; + + friend inline constexpr base &as_base(base &b) { return b; } + friend inline constexpr const base &as_base(const base &b) { return b; } + friend inline constexpr base &&as_base(base &&b) { return lib::move(b); } + friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); } + + friend inline constexpr data_t &data(base &b) { return b.data_; } + friend inline constexpr const data_t &data(const base &b) { return b.data_; } + friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; } + friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; } + + inline static constexpr std::size_t size() { return sizeof...(Ts); } + + data_t data_; + index_t index_; + + friend struct access::base; + friend struct visitation::base; + }; + + struct dtor { +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4100) +#endif + template <typename Alt> + inline void operator()(Alt &alt) const noexcept { alt.~Alt(); } +#ifdef _MSC_VER +#pragma warning(pop) +#endif + }; + +#if !defined(_MSC_VER) || _MSC_VER >= 1910 +#define MPARK_INHERITING_CTOR(type, base) using base::base; +#else +#define MPARK_INHERITING_CTOR(type, base) \ + template <typename... Args> \ + inline explicit constexpr type(Args &&... args) \ + : base(lib::forward<Args>(args)...) {} +#endif + + template <typename Traits, Trait = Traits::destructible_trait> + class destructor; + +#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \ + template <typename... Ts> \ + class destructor<traits<Ts...>, destructible_trait> \ + : public base<destructible_trait, Ts...> { \ + using super = base<destructible_trait, Ts...>; \ + \ + public: \ + MPARK_INHERITING_CTOR(destructor, super) \ + using super::operator=; \ + \ + destructor(const destructor &) = default; \ + destructor(destructor &&) = default; \ + definition \ + destructor &operator=(const destructor &) = default; \ + destructor &operator=(destructor &&) = default; \ + \ + protected: \ + destroy \ + } + + MPARK_VARIANT_DESTRUCTOR( + Trait::TriviallyAvailable, + ~destructor() = default;, + inline void destroy() noexcept { + this->index_ = static_cast<index_t>(-1); + }); + + MPARK_VARIANT_DESTRUCTOR( + Trait::Available, + ~destructor() { destroy(); }, + inline void destroy() noexcept { + if (!this->valueless_by_exception()) { + visitation::alt::visit_alt(dtor{}, *this); + } + this->index_ = static_cast<index_t>(-1); + }); + + MPARK_VARIANT_DESTRUCTOR( + Trait::Unavailable, + ~destructor() = delete;, + inline void destroy() noexcept = delete;); + +#undef MPARK_VARIANT_DESTRUCTOR + + template <typename Traits> + class constructor : public destructor<Traits> { + using super = destructor<Traits>; + + public: + MPARK_INHERITING_CTOR(constructor, super) + using super::operator=; + + protected: +#ifndef MPARK_GENERIC_LAMBDAS + struct ctor { + template <typename LhsAlt, typename RhsAlt> + inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const { + constructor::construct_alt(lhs_alt, + lib::forward<RhsAlt>(rhs_alt).value); + } + }; +#endif + + template <std::size_t I, typename T, typename... Args> + inline static T &construct_alt(alt<I, T> &a, Args &&... args) { + auto *result = ::new (static_cast<void *>(lib::addressof(a))) + alt<I, T>(in_place_t{}, lib::forward<Args>(args)...); + return result->value; + } + + template <typename Rhs> + inline static void generic_construct(constructor &lhs, Rhs &&rhs) { + lhs.destroy(); + if (!rhs.valueless_by_exception()) { + visitation::alt::visit_alt_at( + rhs.index(), +#ifdef MPARK_GENERIC_LAMBDAS + [](auto &lhs_alt, auto &&rhs_alt) { + constructor::construct_alt( + lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value); + } +#else + ctor{} +#endif + , + lhs, + lib::forward<Rhs>(rhs)); + lhs.index_ = rhs.index_; + } + } + }; + + template <typename Traits, Trait = Traits::move_constructible_trait> + class move_constructor; + +#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \ + template <typename... Ts> \ + class move_constructor<traits<Ts...>, move_constructible_trait> \ + : public constructor<traits<Ts...>> { \ + using super = constructor<traits<Ts...>>; \ + \ + public: \ + MPARK_INHERITING_CTOR(move_constructor, super) \ + using super::operator=; \ + \ + move_constructor(const move_constructor &) = default; \ + definition \ + ~move_constructor() = default; \ + move_constructor &operator=(const move_constructor &) = default; \ + move_constructor &operator=(move_constructor &&) = default; \ + } + + MPARK_VARIANT_MOVE_CONSTRUCTOR( + Trait::TriviallyAvailable, + move_constructor(move_constructor &&that) = default;); + + MPARK_VARIANT_MOVE_CONSTRUCTOR( + Trait::Available, + move_constructor(move_constructor &&that) noexcept( + lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value) + : move_constructor(valueless_t{}) { + this->generic_construct(*this, lib::move(that)); + }); + + MPARK_VARIANT_MOVE_CONSTRUCTOR( + Trait::Unavailable, + move_constructor(move_constructor &&) = delete;); + +#undef MPARK_VARIANT_MOVE_CONSTRUCTOR + + template <typename Traits, Trait = Traits::copy_constructible_trait> + class copy_constructor; + +#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \ + template <typename... Ts> \ + class copy_constructor<traits<Ts...>, copy_constructible_trait> \ + : public move_constructor<traits<Ts...>> { \ + using super = move_constructor<traits<Ts...>>; \ + \ + public: \ + MPARK_INHERITING_CTOR(copy_constructor, super) \ + using super::operator=; \ + \ + definition \ + copy_constructor(copy_constructor &&) = default; \ + ~copy_constructor() = default; \ + copy_constructor &operator=(const copy_constructor &) = default; \ + copy_constructor &operator=(copy_constructor &&) = default; \ + } + + MPARK_VARIANT_COPY_CONSTRUCTOR( + Trait::TriviallyAvailable, + copy_constructor(const copy_constructor &that) = default;); + + MPARK_VARIANT_COPY_CONSTRUCTOR( + Trait::Available, + copy_constructor(const copy_constructor &that) + : copy_constructor(valueless_t{}) { + this->generic_construct(*this, that); + }); + + MPARK_VARIANT_COPY_CONSTRUCTOR( + Trait::Unavailable, + copy_constructor(const copy_constructor &) = delete;); + +#undef MPARK_VARIANT_COPY_CONSTRUCTOR + + template <typename Traits> + class assignment : public copy_constructor<Traits> { + using super = copy_constructor<Traits>; + + public: + MPARK_INHERITING_CTOR(assignment, super) + using super::operator=; + + template <std::size_t I, typename... Args> + inline /* auto & */ auto emplace(Args &&... args) + -> decltype(this->construct_alt(access::base::get_alt<I>(*this), + lib::forward<Args>(args)...)) { + this->destroy(); + auto &result = this->construct_alt(access::base::get_alt<I>(*this), + lib::forward<Args>(args)...); + this->index_ = I; + return result; + } + + protected: +#ifndef MPARK_GENERIC_LAMBDAS + template <typename That> + struct assigner { + template <typename ThisAlt, typename ThatAlt> + inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const { + self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value); + } + assignment *self; + }; +#endif + + template <std::size_t I, typename T, typename Arg> + inline void assign_alt(alt<I, T> &a, Arg &&arg) { + if (this->index() == I) { +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4244) +#endif + a.value = lib::forward<Arg>(arg); +#ifdef _MSC_VER +#pragma warning(pop) +#endif + } else { + struct { + void operator()(std::true_type) const { + this_->emplace<I>(lib::forward<Arg>(arg_)); + } + void operator()(std::false_type) const { + this_->emplace<I>(T(lib::forward<Arg>(arg_))); + } + assignment *this_; + Arg &&arg_; + } impl{this, lib::forward<Arg>(arg)}; + impl(lib::bool_constant< + std::is_nothrow_constructible<T, Arg>::value || + !std::is_nothrow_move_constructible<T>::value>{}); + } + } + + template <typename That> + inline void generic_assign(That &&that) { + if (this->valueless_by_exception() && that.valueless_by_exception()) { + // do nothing. + } else if (that.valueless_by_exception()) { + this->destroy(); + } else { + visitation::alt::visit_alt_at( + that.index(), +#ifdef MPARK_GENERIC_LAMBDAS + [this](auto &this_alt, auto &&that_alt) { + this->assign_alt( + this_alt, lib::forward<decltype(that_alt)>(that_alt).value); + } +#else + assigner<That>{this} +#endif + , + *this, + lib::forward<That>(that)); + } + } + }; + + template <typename Traits, Trait = Traits::move_assignable_trait> + class move_assignment; + +#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \ + template <typename... Ts> \ + class move_assignment<traits<Ts...>, move_assignable_trait> \ + : public assignment<traits<Ts...>> { \ + using super = assignment<traits<Ts...>>; \ + \ + public: \ + MPARK_INHERITING_CTOR(move_assignment, super) \ + using super::operator=; \ + \ + move_assignment(const move_assignment &) = default; \ + move_assignment(move_assignment &&) = default; \ + ~move_assignment() = default; \ + move_assignment &operator=(const move_assignment &) = default; \ + definition \ + } + + MPARK_VARIANT_MOVE_ASSIGNMENT( + Trait::TriviallyAvailable, + move_assignment &operator=(move_assignment &&that) = default;); + + MPARK_VARIANT_MOVE_ASSIGNMENT( + Trait::Available, + move_assignment & + operator=(move_assignment &&that) noexcept( + lib::all<(std::is_nothrow_move_constructible<Ts>::value && + std::is_nothrow_move_assignable<Ts>::value)...>::value) { + this->generic_assign(lib::move(that)); + return *this; + }); + + MPARK_VARIANT_MOVE_ASSIGNMENT( + Trait::Unavailable, + move_assignment &operator=(move_assignment &&) = delete;); + +#undef MPARK_VARIANT_MOVE_ASSIGNMENT + + template <typename Traits, Trait = Traits::copy_assignable_trait> + class copy_assignment; + +#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \ + template <typename... Ts> \ + class copy_assignment<traits<Ts...>, copy_assignable_trait> \ + : public move_assignment<traits<Ts...>> { \ + using super = move_assignment<traits<Ts...>>; \ + \ + public: \ + MPARK_INHERITING_CTOR(copy_assignment, super) \ + using super::operator=; \ + \ + copy_assignment(const copy_assignment &) = default; \ + copy_assignment(copy_assignment &&) = default; \ + ~copy_assignment() = default; \ + definition \ + copy_assignment &operator=(copy_assignment &&) = default; \ + } + + MPARK_VARIANT_COPY_ASSIGNMENT( + Trait::TriviallyAvailable, + copy_assignment &operator=(const copy_assignment &that) = default;); + + MPARK_VARIANT_COPY_ASSIGNMENT( + Trait::Available, + copy_assignment &operator=(const copy_assignment &that) { + this->generic_assign(that); + return *this; + }); + + MPARK_VARIANT_COPY_ASSIGNMENT( + Trait::Unavailable, + copy_assignment &operator=(const copy_assignment &) = delete;); + +#undef MPARK_VARIANT_COPY_ASSIGNMENT + + template <typename... Ts> + class impl : public copy_assignment<traits<Ts...>> { + using super = copy_assignment<traits<Ts...>>; + + public: + MPARK_INHERITING_CTOR(impl, super) + using super::operator=; + + template <std::size_t I, typename Arg> + inline void assign(Arg &&arg) { + this->assign_alt(access::base::get_alt<I>(*this), + lib::forward<Arg>(arg)); + } + + inline void swap(impl &that) { + if (this->valueless_by_exception() && that.valueless_by_exception()) { + // do nothing. + } else if (this->index() == that.index()) { + visitation::alt::visit_alt_at(this->index(), +#ifdef MPARK_GENERIC_LAMBDAS + [](auto &this_alt, auto &that_alt) { + using std::swap; + swap(this_alt.value, + that_alt.value); + } +#else + swapper{} +#endif + , + *this, + that); + } else { + impl *lhs = this; + impl *rhs = lib::addressof(that); + if (lhs->move_nothrow() && !rhs->move_nothrow()) { + std::swap(lhs, rhs); + } + impl tmp(lib::move(*rhs)); +#ifdef MPARK_EXCEPTIONS + // EXTENSION: When the move construction of `lhs` into `rhs` throws + // and `tmp` is nothrow move constructible then we move `tmp` back + // into `rhs` and provide the strong exception safety guarantee. + try { + this->generic_construct(*rhs, lib::move(*lhs)); + } catch (...) { + if (tmp.move_nothrow()) { + this->generic_construct(*rhs, lib::move(tmp)); + } + throw; + } +#else + this->generic_construct(*rhs, lib::move(*lhs)); +#endif + this->generic_construct(*lhs, lib::move(tmp)); + } + } + + private: +#ifndef MPARK_GENERIC_LAMBDAS + struct swapper { + template <typename ThisAlt, typename ThatAlt> + inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const { + using std::swap; + swap(this_alt.value, that_alt.value); + } + }; +#endif + + inline constexpr bool move_nothrow() const { + return this->valueless_by_exception() || + lib::array<bool, sizeof...(Ts)>{ + {std::is_nothrow_move_constructible<Ts>::value...} + }[this->index()]; + } + }; + +#undef MPARK_INHERITING_CTOR + + template <std::size_t I, typename T> + struct overload_leaf { + using F = lib::size_constant<I> (*)(T); + operator F() const { return nullptr; } + }; + + template <typename... Ts> + struct overload_impl { + private: + template <typename> + struct impl; + + template <std::size_t... Is> + struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {}; + + public: + using type = impl<lib::index_sequence_for<Ts...>>; + }; + + template <typename... Ts> + using overload = typename overload_impl<Ts...>::type; + + template <typename T, typename... Ts> + using best_match = lib::invoke_result_t<overload<Ts...>, T &&>; + + template <typename T> + struct is_in_place_index : std::false_type {}; + + template <std::size_t I> + struct is_in_place_index<in_place_index_t<I>> : std::true_type {}; + + template <typename T> + struct is_in_place_type : std::false_type {}; + + template <typename T> + struct is_in_place_type<in_place_type_t<T>> : std::true_type {}; + + } // detail + + template <typename... Ts> + class variant { + static_assert(0 < sizeof...(Ts), + "variant must consist of at least one alternative."); + + static_assert(lib::all<!std::is_array<Ts>::value...>::value, + "variant can not have an array type as an alternative."); + + static_assert(lib::all<!std::is_reference<Ts>::value...>::value, + "variant can not have a reference type as an alternative."); + + static_assert(lib::all<!std::is_void<Ts>::value...>::value, + "variant can not have a void type as an alternative."); + + public: + template < + typename Front = lib::type_pack_element_t<0, Ts...>, + lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0> + inline constexpr variant() noexcept( + std::is_nothrow_default_constructible<Front>::value) + : impl_(in_place_index_t<0>{}) {} + + variant(const variant &) = default; + variant(variant &&) = default; + + template < + typename Arg, + typename Decayed = lib::decay_t<Arg>, + lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0, + lib::enable_if_t<!detail::is_in_place_index<Decayed>::value, int> = 0, + lib::enable_if_t<!detail::is_in_place_type<Decayed>::value, int> = 0, + std::size_t I = detail::best_match<Arg, Ts...>::value, + typename T = lib::type_pack_element_t<I, Ts...>, + lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0> + inline constexpr variant(Arg &&arg) noexcept( + std::is_nothrow_constructible<T, Arg>::value) + : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {} + + template < + std::size_t I, + typename... Args, + typename T = lib::type_pack_element_t<I, Ts...>, + lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0> + inline explicit constexpr variant( + in_place_index_t<I>, + Args &&... args) noexcept(std::is_nothrow_constructible<T, + Args...>::value) + : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {} + + template < + std::size_t I, + typename Up, + typename... Args, + typename T = lib::type_pack_element_t<I, Ts...>, + lib::enable_if_t<std::is_constructible<T, + std::initializer_list<Up> &, + Args...>::value, + int> = 0> + inline explicit constexpr variant( + in_place_index_t<I>, + std::initializer_list<Up> il, + Args &&... args) noexcept(std:: + is_nothrow_constructible< + T, + std::initializer_list<Up> &, + Args...>::value) + : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {} + + template < + typename T, + typename... Args, + std::size_t I = detail::find_index_sfinae<T, Ts...>::value, + lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0> + inline explicit constexpr variant( + in_place_type_t<T>, + Args &&... args) noexcept(std::is_nothrow_constructible<T, + Args...>::value) + : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {} + + template < + typename T, + typename Up, + typename... Args, + std::size_t I = detail::find_index_sfinae<T, Ts...>::value, + lib::enable_if_t<std::is_constructible<T, + std::initializer_list<Up> &, + Args...>::value, + int> = 0> + inline explicit constexpr variant( + in_place_type_t<T>, + std::initializer_list<Up> il, + Args &&... args) noexcept(std:: + is_nothrow_constructible< + T, + std::initializer_list<Up> &, + Args...>::value) + : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {} + + ~variant() = default; + + variant &operator=(const variant &) = default; + variant &operator=(variant &&) = default; + + template <typename Arg, + lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value, + int> = 0, + std::size_t I = detail::best_match<Arg, Ts...>::value, + typename T = lib::type_pack_element_t<I, Ts...>, + lib::enable_if_t<(std::is_assignable<T &, Arg>::value && + std::is_constructible<T, Arg>::value), + int> = 0> + inline variant &operator=(Arg &&arg) noexcept( + (std::is_nothrow_assignable<T &, Arg>::value && + std::is_nothrow_constructible<T, Arg>::value)) { + impl_.template assign<I>(lib::forward<Arg>(arg)); + return *this; + } + + template < + std::size_t I, + typename... Args, + typename T = lib::type_pack_element_t<I, Ts...>, + lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0> + inline T &emplace(Args &&... args) { + return impl_.template emplace<I>(lib::forward<Args>(args)...); + } + + template < + std::size_t I, + typename Up, + typename... Args, + typename T = lib::type_pack_element_t<I, Ts...>, + lib::enable_if_t<std::is_constructible<T, + std::initializer_list<Up> &, + Args...>::value, + int> = 0> + inline T &emplace(std::initializer_list<Up> il, Args &&... args) { + return impl_.template emplace<I>(il, lib::forward<Args>(args)...); + } + + template < + typename T, + typename... Args, + std::size_t I = detail::find_index_sfinae<T, Ts...>::value, + lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0> + inline T &emplace(Args &&... args) { + return impl_.template emplace<I>(lib::forward<Args>(args)...); + } + + template < + typename T, + typename Up, + typename... Args, + std::size_t I = detail::find_index_sfinae<T, Ts...>::value, + lib::enable_if_t<std::is_constructible<T, + std::initializer_list<Up> &, + Args...>::value, + int> = 0> + inline T &emplace(std::initializer_list<Up> il, Args &&... args) { + return impl_.template emplace<I>(il, lib::forward<Args>(args)...); + } + + inline constexpr bool valueless_by_exception() const noexcept { + return impl_.valueless_by_exception(); + } + + inline constexpr std::size_t index() const noexcept { + return impl_.index(); + } + + template <bool Dummy = true, + lib::enable_if_t< + lib::all<Dummy, + (lib::dependent_type<std::is_move_constructible<Ts>, + Dummy>::value && + lib::dependent_type<lib::is_swappable<Ts>, + Dummy>::value)...>::value, + int> = 0> + inline void swap(variant &that) noexcept( + lib::all<(std::is_nothrow_move_constructible<Ts>::value && + lib::is_nothrow_swappable<Ts>::value)...>::value) { + impl_.swap(that.impl_); + } + + private: + detail::impl<Ts...> impl_; + + friend struct detail::access::variant; + friend struct detail::visitation::variant; + }; + + template <std::size_t I, typename... Ts> + inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept { + return v.index() == I; + } + + template <typename T, typename... Ts> + inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept { + return holds_alternative<detail::find_index_checked<T, Ts...>::value>(v); + } + + namespace detail { + template <std::size_t I, typename V> + struct generic_get_impl { + constexpr generic_get_impl(int) noexcept {} + + constexpr AUTO_REFREF operator()(V &&v) const + AUTO_REFREF_RETURN( + access::variant::get_alt<I>(lib::forward<V>(v)).value) + }; + + template <std::size_t I, typename V> + inline constexpr AUTO_REFREF generic_get(V &&v) + AUTO_REFREF_RETURN(generic_get_impl<I, V>( + holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))( + lib::forward<V>(v))) + } // namespace detail + + template <std::size_t I, typename... Ts> + inline constexpr variant_alternative_t<I, variant<Ts...>> &get( + variant<Ts...> &v) { + return detail::generic_get<I>(v); + } + + template <std::size_t I, typename... Ts> + inline constexpr variant_alternative_t<I, variant<Ts...>> &&get( + variant<Ts...> &&v) { + return detail::generic_get<I>(lib::move(v)); + } + + template <std::size_t I, typename... Ts> + inline constexpr const variant_alternative_t<I, variant<Ts...>> &get( + const variant<Ts...> &v) { + return detail::generic_get<I>(v); + } + + template <std::size_t I, typename... Ts> + inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get( + const variant<Ts...> &&v) { + return detail::generic_get<I>(lib::move(v)); + } + + template <typename T, typename... Ts> + inline constexpr T &get(variant<Ts...> &v) { + return get<detail::find_index_checked<T, Ts...>::value>(v); + } + + template <typename T, typename... Ts> + inline constexpr T &&get(variant<Ts...> &&v) { + return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v)); + } + + template <typename T, typename... Ts> + inline constexpr const T &get(const variant<Ts...> &v) { + return get<detail::find_index_checked<T, Ts...>::value>(v); + } + + template <typename T, typename... Ts> + inline constexpr const T &&get(const variant<Ts...> &&v) { + return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v)); + } + + namespace detail { + + template <std::size_t I, typename V> + inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept + AUTO_RETURN(v && holds_alternative<I>(*v) + ? lib::addressof(access::variant::get_alt<I>(*v).value) + : nullptr) + + } // namespace detail + + template <std::size_t I, typename... Ts> + inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>> + get_if(variant<Ts...> *v) noexcept { + return detail::generic_get_if<I>(v); + } + + template <std::size_t I, typename... Ts> + inline constexpr lib::add_pointer_t< + const variant_alternative_t<I, variant<Ts...>>> + get_if(const variant<Ts...> *v) noexcept { + return detail::generic_get_if<I>(v); + } + + template <typename T, typename... Ts> + inline constexpr lib::add_pointer_t<T> + get_if(variant<Ts...> *v) noexcept { + return get_if<detail::find_index_checked<T, Ts...>::value>(v); + } + + template <typename T, typename... Ts> + inline constexpr lib::add_pointer_t<const T> + get_if(const variant<Ts...> *v) noexcept { + return get_if<detail::find_index_checked<T, Ts...>::value>(v); + } + + namespace detail { + template <typename RelOp> + struct convert_to_bool { + template <typename Lhs, typename Rhs> + inline constexpr bool operator()(Lhs &&lhs, Rhs &&rhs) const { + static_assert(std::is_convertible<lib::invoke_result_t<RelOp, Lhs, Rhs>, + bool>::value, + "relational operators must return a type" + " implicitly convertible to bool"); + return lib::invoke( + RelOp{}, lib::forward<Lhs>(lhs), lib::forward<Rhs>(rhs)); + } + }; + } // namespace detail + + template <typename... Ts> + inline constexpr bool operator==(const variant<Ts...> &lhs, + const variant<Ts...> &rhs) { + using detail::visitation::variant; + using equal_to = detail::convert_to_bool<lib::equal_to>; +#ifdef MPARK_CPP14_CONSTEXPR + if (lhs.index() != rhs.index()) return false; + if (lhs.valueless_by_exception()) return true; + return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs); +#else + return lhs.index() == rhs.index() && + (lhs.valueless_by_exception() || + variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs)); +#endif + } + + template <typename... Ts> + inline constexpr bool operator!=(const variant<Ts...> &lhs, + const variant<Ts...> &rhs) { + using detail::visitation::variant; + using not_equal_to = detail::convert_to_bool<lib::not_equal_to>; +#ifdef MPARK_CPP14_CONSTEXPR + if (lhs.index() != rhs.index()) return true; + if (lhs.valueless_by_exception()) return false; + return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs); +#else + return lhs.index() != rhs.index() || + (!lhs.valueless_by_exception() && + variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs)); +#endif + } + + template <typename... Ts> + inline constexpr bool operator<(const variant<Ts...> &lhs, + const variant<Ts...> &rhs) { + using detail::visitation::variant; + using less = detail::convert_to_bool<lib::less>; +#ifdef MPARK_CPP14_CONSTEXPR + if (rhs.valueless_by_exception()) return false; + if (lhs.valueless_by_exception()) return true; + if (lhs.index() < rhs.index()) return true; + if (lhs.index() > rhs.index()) return false; + return variant::visit_value_at(lhs.index(), less{}, lhs, rhs); +#else + return !rhs.valueless_by_exception() && + (lhs.valueless_by_exception() || lhs.index() < rhs.index() || + (lhs.index() == rhs.index() && + variant::visit_value_at(lhs.index(), less{}, lhs, rhs))); +#endif + } + + template <typename... Ts> + inline constexpr bool operator>(const variant<Ts...> &lhs, + const variant<Ts...> &rhs) { + using detail::visitation::variant; + using greater = detail::convert_to_bool<lib::greater>; +#ifdef MPARK_CPP14_CONSTEXPR + if (lhs.valueless_by_exception()) return false; + if (rhs.valueless_by_exception()) return true; + if (lhs.index() > rhs.index()) return true; + if (lhs.index() < rhs.index()) return false; + return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs); +#else + return !lhs.valueless_by_exception() && + (rhs.valueless_by_exception() || lhs.index() > rhs.index() || + (lhs.index() == rhs.index() && + variant::visit_value_at(lhs.index(), greater{}, lhs, rhs))); +#endif + } + + template <typename... Ts> + inline constexpr bool operator<=(const variant<Ts...> &lhs, + const variant<Ts...> &rhs) { + using detail::visitation::variant; + using less_equal = detail::convert_to_bool<lib::less_equal>; +#ifdef MPARK_CPP14_CONSTEXPR + if (lhs.valueless_by_exception()) return true; + if (rhs.valueless_by_exception()) return false; + if (lhs.index() < rhs.index()) return true; + if (lhs.index() > rhs.index()) return false; + return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs); +#else + return lhs.valueless_by_exception() || + (!rhs.valueless_by_exception() && + (lhs.index() < rhs.index() || + (lhs.index() == rhs.index() && + variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs)))); +#endif + } + + template <typename... Ts> + inline constexpr bool operator>=(const variant<Ts...> &lhs, + const variant<Ts...> &rhs) { + using detail::visitation::variant; + using greater_equal = detail::convert_to_bool<lib::greater_equal>; +#ifdef MPARK_CPP14_CONSTEXPR + if (rhs.valueless_by_exception()) return true; + if (lhs.valueless_by_exception()) return false; + if (lhs.index() > rhs.index()) return true; + if (lhs.index() < rhs.index()) return false; + return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs); +#else + return rhs.valueless_by_exception() || + (!lhs.valueless_by_exception() && + (lhs.index() > rhs.index() || + (lhs.index() == rhs.index() && + variant::visit_value_at( + lhs.index(), greater_equal{}, lhs, rhs)))); +#endif + } + + struct monostate {}; + + inline constexpr bool operator<(monostate, monostate) noexcept { + return false; + } + + inline constexpr bool operator>(monostate, monostate) noexcept { + return false; + } + + inline constexpr bool operator<=(monostate, monostate) noexcept { + return true; + } + + inline constexpr bool operator>=(monostate, monostate) noexcept { + return true; + } + + inline constexpr bool operator==(monostate, monostate) noexcept { + return true; + } + + inline constexpr bool operator!=(monostate, monostate) noexcept { + return false; + } + +#ifdef MPARK_CPP14_CONSTEXPR + namespace detail { + + inline constexpr bool all(std::initializer_list<bool> bs) { + for (bool b : bs) { + if (!b) { + return false; + } + } + return true; + } + + } // namespace detail + + template <typename Visitor, typename... Vs> + inline constexpr decltype(auto) visit(Visitor &&visitor, Vs &&... vs) { + return (detail::all({!vs.valueless_by_exception()...}) + ? (void)0 + : throw_bad_variant_access()), + detail::visitation::variant::visit_value( + lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...); + } +#else + namespace detail { + + template <std::size_t N> + inline constexpr bool all_impl(const lib::array<bool, N> &bs, + std::size_t idx) { + return idx >= N || (bs[idx] && all_impl(bs, idx + 1)); + } + + template <std::size_t N> + inline constexpr bool all(const lib::array<bool, N> &bs) { + return all_impl(bs, 0); + } + + } // namespace detail + + template <typename Visitor, typename... Vs> + inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs) + DECLTYPE_AUTO_RETURN( + (detail::all( + lib::array<bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}}) + ? (void)0 + : throw_bad_variant_access()), + detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor), + lib::forward<Vs>(vs)...)) +#endif + + template <typename... Ts> + inline auto swap(variant<Ts...> &lhs, + variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs))) + -> decltype(lhs.swap(rhs)) { + lhs.swap(rhs); + } + + namespace detail { + + template <typename T, typename...> + using enabled_type = T; + + namespace hash { + + template <typename H, typename K> + constexpr bool meets_requirements() noexcept { + return std::is_copy_constructible<H>::value && + std::is_move_constructible<H>::value && + lib::is_invocable_r<std::size_t, H, const K &>::value; + } + + template <typename K> + constexpr bool is_enabled() noexcept { + using H = std::hash<K>; + return meets_requirements<H, K>() && + std::is_default_constructible<H>::value && + std::is_copy_assignable<H>::value && + std::is_move_assignable<H>::value; + } + + } // namespace hash + + } // namespace detail + +#undef AUTO +#undef AUTO_RETURN + +#undef AUTO_REFREF +#undef AUTO_REFREF_RETURN + +#undef DECLTYPE_AUTO +#undef DECLTYPE_AUTO_RETURN + +} // namespace mpark + +namespace std { + + template <typename... Ts> + struct hash<mpark::detail::enabled_type< + mpark::variant<Ts...>, + mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled< + mpark::lib::remove_const_t<Ts>>()...>::value>>> { + using argument_type = mpark::variant<Ts...>; + using result_type = std::size_t; + + inline result_type operator()(const argument_type &v) const { + using mpark::detail::visitation::variant; + std::size_t result = + v.valueless_by_exception() + ? 299792458 // Random value chosen by the universe upon creation + : variant::visit_alt( +#ifdef MPARK_GENERIC_LAMBDAS + [](const auto &alt) { + using alt_type = mpark::lib::decay_t<decltype(alt)>; + using value_type = mpark::lib::remove_const_t< + typename alt_type::value_type>; + return hash<value_type>{}(alt.value); + } +#else + hasher{} +#endif + , + v); + return hash_combine(result, hash<std::size_t>{}(v.index())); + } + + private: +#ifndef MPARK_GENERIC_LAMBDAS + struct hasher { + template <typename Alt> + inline std::size_t operator()(const Alt &alt) const { + using alt_type = mpark::lib::decay_t<Alt>; + using value_type = + mpark::lib::remove_const_t<typename alt_type::value_type>; + return hash<value_type>{}(alt.value); + } + }; +#endif + + static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) { + return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2); + } + }; + + template <> + struct hash<mpark::monostate> { + using argument_type = mpark::monostate; + using result_type = std::size_t; + + inline result_type operator()(const argument_type &) const noexcept { + return 66740831; // return a fundamentally attractive random value. + } + }; + +} // namespace std + +#endif // MPARK_VARIANT_HPP |