Thanks for using Compiler Explorer
Sponsors
Jakt
C++
Ada
Analysis
Android Java
Android Kotlin
Assembly
C
C3
Carbon
C++ (Circle)
CIRCT
Clean
CMake
CMakeScript
COBOL
C++ for OpenCL
MLIR
Cppx
Cppx-Blue
Cppx-Gold
Cpp2-cppfront
Crystal
C#
CUDA C++
D
Dart
Elixir
Erlang
Fortran
F#
GLSL
Go
Haskell
HLSL
Hook
Hylo
IL
ispc
Java
Julia
Kotlin
LLVM IR
LLVM MIR
Modula-2
Nim
Objective-C
Objective-C++
OCaml
OpenCL C
Pascal
Pony
Python
Racket
Ruby
Rust
Snowball
Scala
Solidity
Spice
Swift
LLVM TableGen
Toit
TypeScript Native
V
Vala
Visual Basic
WASM
Zig
Javascript
GIMPLE
c++ source #1
Output
Compile to binary object
Link to binary
Execute the code
Intel asm syntax
Demangle identifiers
Verbose demangling
Filters
Unused labels
Library functions
Directives
Comments
Horizontal whitespace
Debug intrinsics
Compiler
6502-c++ 11.1.0
ARM GCC 10.2.0
ARM GCC 10.3.0
ARM GCC 10.4.0
ARM GCC 10.5.0
ARM GCC 11.1.0
ARM GCC 11.2.0
ARM GCC 11.3.0
ARM GCC 11.4.0
ARM GCC 12.1.0
ARM GCC 12.2.0
ARM GCC 12.3.0
ARM GCC 12.4.0
ARM GCC 13.1.0
ARM GCC 13.2.0
ARM GCC 13.2.0 (unknown-eabi)
ARM GCC 13.3.0
ARM GCC 13.3.0 (unknown-eabi)
ARM GCC 14.1.0
ARM GCC 14.1.0 (unknown-eabi)
ARM GCC 14.2.0
ARM GCC 14.2.0 (unknown-eabi)
ARM GCC 4.5.4
ARM GCC 4.6.4
ARM GCC 5.4
ARM GCC 6.3.0
ARM GCC 6.4.0
ARM GCC 7.3.0
ARM GCC 7.5.0
ARM GCC 8.2.0
ARM GCC 8.5.0
ARM GCC 9.3.0
ARM GCC 9.4.0
ARM GCC 9.5.0
ARM GCC trunk
ARM gcc 10.2.1 (none)
ARM gcc 10.3.1 (2021.07 none)
ARM gcc 10.3.1 (2021.10 none)
ARM gcc 11.2.1 (none)
ARM gcc 5.4.1 (none)
ARM gcc 7.2.1 (none)
ARM gcc 8.2 (WinCE)
ARM gcc 8.3.1 (none)
ARM gcc 9.2.1 (none)
ARM msvc v19.0 (WINE)
ARM msvc v19.10 (WINE)
ARM msvc v19.14 (WINE)
ARM64 Morello gcc 10.1 Alpha 2
ARM64 gcc 10.2
ARM64 gcc 10.3
ARM64 gcc 10.4
ARM64 gcc 10.5.0
ARM64 gcc 11.1
ARM64 gcc 11.2
ARM64 gcc 11.3
ARM64 gcc 11.4.0
ARM64 gcc 12.1
ARM64 gcc 12.2.0
ARM64 gcc 12.3.0
ARM64 gcc 12.4.0
ARM64 gcc 13.1.0
ARM64 gcc 13.2.0
ARM64 gcc 13.3.0
ARM64 gcc 14.1.0
ARM64 gcc 14.2.0
ARM64 gcc 4.9.4
ARM64 gcc 5.4
ARM64 gcc 5.5.0
ARM64 gcc 6.3
ARM64 gcc 6.4
ARM64 gcc 7.3
ARM64 gcc 7.5
ARM64 gcc 8.2
ARM64 gcc 8.5
ARM64 gcc 9.3
ARM64 gcc 9.4
ARM64 gcc 9.5
ARM64 gcc trunk
ARM64 msvc v19.14 (WINE)
AVR gcc 10.3.0
AVR gcc 11.1.0
AVR gcc 12.1.0
AVR gcc 12.2.0
AVR gcc 12.3.0
AVR gcc 12.4.0
AVR gcc 13.1.0
AVR gcc 13.2.0
AVR gcc 13.3.0
AVR gcc 14.1.0
AVR gcc 14.2.0
AVR gcc 4.5.4
AVR gcc 4.6.4
AVR gcc 5.4.0
AVR gcc 9.2.0
AVR gcc 9.3.0
Arduino Mega (1.8.9)
Arduino Uno (1.8.9)
BPF clang (trunk)
BPF clang 13.0.0
BPF clang 14.0.0
BPF clang 15.0.0
BPF clang 16.0.0
BPF clang 17.0.1
BPF clang 18.1.0
BPF clang 19.1.0
BPF gcc 13.1.0
BPF gcc 13.2.0
BPF gcc 13.3.0
BPF gcc trunk
EDG (experimental reflection)
EDG 6.5
EDG 6.5 (GNU mode gcc 13)
EDG 6.6
EDG 6.6 (GNU mode gcc 13)
FRC 2019
FRC 2020
FRC 2023
HPPA gcc 14.2.0
KVX ACB 4.1.0 (GCC 7.5.0)
KVX ACB 4.1.0-cd1 (GCC 7.5.0)
KVX ACB 4.10.0 (GCC 10.3.1)
KVX ACB 4.11.1 (GCC 10.3.1)
KVX ACB 4.12.0 (GCC 11.3.0)
KVX ACB 4.2.0 (GCC 7.5.0)
KVX ACB 4.3.0 (GCC 7.5.0)
KVX ACB 4.4.0 (GCC 7.5.0)
KVX ACB 4.6.0 (GCC 9.4.1)
KVX ACB 4.8.0 (GCC 9.4.1)
KVX ACB 4.9.0 (GCC 9.4.1)
KVX ACB 5.0.0 (GCC 12.2.1)
LoongArch64 clang (trunk)
LoongArch64 clang 17.0.1
LoongArch64 clang 18.1.0
LoongArch64 clang 19.1.0
M68K gcc 13.1.0
M68K gcc 13.2.0
M68K gcc 13.3.0
M68K gcc 14.1.0
M68K gcc 14.2.0
M68k clang (trunk)
MRISC32 gcc (trunk)
MSP430 gcc 4.5.3
MSP430 gcc 5.3.0
MSP430 gcc 6.2.1
MinGW clang 14.0.3
MinGW clang 14.0.6
MinGW clang 15.0.7
MinGW clang 16.0.0
MinGW clang 16.0.2
MinGW gcc 11.3.0
MinGW gcc 12.1.0
MinGW gcc 12.2.0
MinGW gcc 13.1.0
RISC-V (32-bits) gcc (trunk)
RISC-V (32-bits) gcc 10.2.0
RISC-V (32-bits) gcc 10.3.0
RISC-V (32-bits) gcc 11.2.0
RISC-V (32-bits) gcc 11.3.0
RISC-V (32-bits) gcc 11.4.0
RISC-V (32-bits) gcc 12.1.0
RISC-V (32-bits) gcc 12.2.0
RISC-V (32-bits) gcc 12.3.0
RISC-V (32-bits) gcc 12.4.0
RISC-V (32-bits) gcc 13.1.0
RISC-V (32-bits) gcc 13.2.0
RISC-V (32-bits) gcc 13.3.0
RISC-V (32-bits) gcc 14.1.0
RISC-V (32-bits) gcc 14.2.0
RISC-V (32-bits) gcc 8.2.0
RISC-V (32-bits) gcc 8.5.0
RISC-V (32-bits) gcc 9.4.0
RISC-V (64-bits) gcc (trunk)
RISC-V (64-bits) gcc 10.2.0
RISC-V (64-bits) gcc 10.3.0
RISC-V (64-bits) gcc 11.2.0
RISC-V (64-bits) gcc 11.3.0
RISC-V (64-bits) gcc 11.4.0
RISC-V (64-bits) gcc 12.1.0
RISC-V (64-bits) gcc 12.2.0
RISC-V (64-bits) gcc 12.3.0
RISC-V (64-bits) gcc 12.4.0
RISC-V (64-bits) gcc 13.1.0
RISC-V (64-bits) gcc 13.2.0
RISC-V (64-bits) gcc 13.3.0
RISC-V (64-bits) gcc 14.1.0
RISC-V (64-bits) gcc 14.2.0
RISC-V (64-bits) gcc 8.2.0
RISC-V (64-bits) gcc 8.5.0
RISC-V (64-bits) gcc 9.4.0
RISC-V rv32gc clang (trunk)
RISC-V rv32gc clang 10.0.0
RISC-V rv32gc clang 10.0.1
RISC-V rv32gc clang 11.0.0
RISC-V rv32gc clang 11.0.1
RISC-V rv32gc clang 12.0.0
RISC-V rv32gc clang 12.0.1
RISC-V rv32gc clang 13.0.0
RISC-V rv32gc clang 13.0.1
RISC-V rv32gc clang 14.0.0
RISC-V rv32gc clang 15.0.0
RISC-V rv32gc clang 16.0.0
RISC-V rv32gc clang 17.0.1
RISC-V rv32gc clang 18.1.0
RISC-V rv32gc clang 19.1.0
RISC-V rv32gc clang 9.0.0
RISC-V rv32gc clang 9.0.1
RISC-V rv64gc clang (trunk)
RISC-V rv64gc clang 10.0.0
RISC-V rv64gc clang 10.0.1
RISC-V rv64gc clang 11.0.0
RISC-V rv64gc clang 11.0.1
RISC-V rv64gc clang 12.0.0
RISC-V rv64gc clang 12.0.1
RISC-V rv64gc clang 13.0.0
RISC-V rv64gc clang 13.0.1
RISC-V rv64gc clang 14.0.0
RISC-V rv64gc clang 15.0.0
RISC-V rv64gc clang 16.0.0
RISC-V rv64gc clang 17.0.1
RISC-V rv64gc clang 18.1.0
RISC-V rv64gc clang 19.1.0
RISC-V rv64gc clang 9.0.0
RISC-V rv64gc clang 9.0.1
Raspbian Buster
Raspbian Stretch
SPARC LEON gcc 12.2.0
SPARC LEON gcc 12.3.0
SPARC LEON gcc 12.4.0
SPARC LEON gcc 13.1.0
SPARC LEON gcc 13.2.0
SPARC LEON gcc 13.3.0
SPARC LEON gcc 14.1.0
SPARC LEON gcc 14.2.0
SPARC gcc 12.2.0
SPARC gcc 12.3.0
SPARC gcc 12.4.0
SPARC gcc 13.1.0
SPARC gcc 13.2.0
SPARC gcc 13.3.0
SPARC gcc 14.1.0
SPARC gcc 14.2.0
SPARC64 gcc 12.2.0
SPARC64 gcc 12.3.0
SPARC64 gcc 12.4.0
SPARC64 gcc 13.1.0
SPARC64 gcc 13.2.0
SPARC64 gcc 13.3.0
SPARC64 gcc 14.1.0
SPARC64 gcc 14.2.0
TI C6x gcc 12.2.0
TI C6x gcc 12.3.0
TI C6x gcc 12.4.0
TI C6x gcc 13.1.0
TI C6x gcc 13.2.0
TI C6x gcc 13.3.0
TI C6x gcc 14.1.0
TI C6x gcc 14.2.0
TI CL430 21.6.1
VAX gcc NetBSDELF 10.4.0
VAX gcc NetBSDELF 10.5.0 (Nov 15 03:50:22 2023)
WebAssembly clang (trunk)
Xtensa ESP32 gcc 11.2.0 (2022r1)
Xtensa ESP32 gcc 12.2.0 (20230208)
Xtensa ESP32 gcc 8.2.0 (2019r2)
Xtensa ESP32 gcc 8.2.0 (2020r1)
Xtensa ESP32 gcc 8.2.0 (2020r2)
Xtensa ESP32 gcc 8.4.0 (2020r3)
Xtensa ESP32 gcc 8.4.0 (2021r1)
Xtensa ESP32 gcc 8.4.0 (2021r2)
Xtensa ESP32-S2 gcc 11.2.0 (2022r1)
Xtensa ESP32-S2 gcc 12.2.0 (20230208)
Xtensa ESP32-S2 gcc 8.2.0 (2019r2)
Xtensa ESP32-S2 gcc 8.2.0 (2020r1)
Xtensa ESP32-S2 gcc 8.2.0 (2020r2)
Xtensa ESP32-S2 gcc 8.4.0 (2020r3)
Xtensa ESP32-S2 gcc 8.4.0 (2021r1)
Xtensa ESP32-S2 gcc 8.4.0 (2021r2)
Xtensa ESP32-S3 gcc 11.2.0 (2022r1)
Xtensa ESP32-S3 gcc 12.2.0 (20230208)
Xtensa ESP32-S3 gcc 8.4.0 (2020r3)
Xtensa ESP32-S3 gcc 8.4.0 (2021r1)
Xtensa ESP32-S3 gcc 8.4.0 (2021r2)
arm64 msvc v19.20 VS16.0
arm64 msvc v19.21 VS16.1
arm64 msvc v19.22 VS16.2
arm64 msvc v19.23 VS16.3
arm64 msvc v19.24 VS16.4
arm64 msvc v19.25 VS16.5
arm64 msvc v19.27 VS16.7
arm64 msvc v19.28 VS16.8
arm64 msvc v19.28 VS16.9
arm64 msvc v19.29 VS16.10
arm64 msvc v19.29 VS16.11
arm64 msvc v19.30 VS17.0
arm64 msvc v19.31 VS17.1
arm64 msvc v19.32 VS17.2
arm64 msvc v19.33 VS17.3
arm64 msvc v19.34 VS17.4
arm64 msvc v19.35 VS17.5
arm64 msvc v19.36 VS17.6
arm64 msvc v19.37 VS17.7
arm64 msvc v19.38 VS17.8
arm64 msvc v19.39 VS17.9
arm64 msvc v19.40 VS17.10
arm64 msvc v19.latest
armv7-a clang (trunk)
armv7-a clang 10.0.0
armv7-a clang 10.0.1
armv7-a clang 11.0.0
armv7-a clang 11.0.1
armv7-a clang 12.0.0
armv7-a clang 12.0.1
armv7-a clang 13.0.0
armv7-a clang 13.0.1
armv7-a clang 14.0.0
armv7-a clang 15.0.0
armv7-a clang 16.0.0
armv7-a clang 17.0.1
armv7-a clang 18.1.0
armv7-a clang 19.1.0
armv7-a clang 9.0.0
armv7-a clang 9.0.1
armv8-a clang (all architectural features, trunk)
armv8-a clang (trunk)
armv8-a clang 10.0.0
armv8-a clang 10.0.1
armv8-a clang 11.0.0
armv8-a clang 11.0.1
armv8-a clang 12.0.0
armv8-a clang 13.0.0
armv8-a clang 14.0.0
armv8-a clang 15.0.0
armv8-a clang 16.0.0
armv8-a clang 17.0.1
armv8-a clang 18.1.0
armv8-a clang 19.1.0
armv8-a clang 9.0.0
armv8-a clang 9.0.1
clang-cl 18.1.0
ellcc 0.1.33
ellcc 0.1.34
ellcc 2017-07-16
hexagon-clang 16.0.5
llvm-mos atari2600-3e
llvm-mos atari2600-4k
llvm-mos atari2600-common
llvm-mos atari5200-supercart
llvm-mos atari8-cart-megacart
llvm-mos atari8-cart-std
llvm-mos atari8-cart-xegs
llvm-mos atari8-common
llvm-mos atari8-dos
llvm-mos c128
llvm-mos c64
llvm-mos commodore
llvm-mos cpm65
llvm-mos cx16
llvm-mos dodo
llvm-mos eater
llvm-mos mega65
llvm-mos nes
llvm-mos nes-action53
llvm-mos nes-cnrom
llvm-mos nes-gtrom
llvm-mos nes-mmc1
llvm-mos nes-mmc3
llvm-mos nes-nrom
llvm-mos nes-unrom
llvm-mos nes-unrom-512
llvm-mos osi-c1p
llvm-mos pce
llvm-mos pce-cd
llvm-mos pce-common
llvm-mos pet
llvm-mos rp6502
llvm-mos rpc8e
llvm-mos supervision
llvm-mos vic20
loongarch64 gcc 12.2.0
loongarch64 gcc 12.3.0
loongarch64 gcc 12.4.0
loongarch64 gcc 13.1.0
loongarch64 gcc 13.2.0
loongarch64 gcc 13.3.0
loongarch64 gcc 14.1.0
loongarch64 gcc 14.2.0
mips clang 13.0.0
mips clang 14.0.0
mips clang 15.0.0
mips clang 16.0.0
mips clang 17.0.1
mips clang 18.1.0
mips clang 19.1.0
mips gcc 11.2.0
mips gcc 12.1.0
mips gcc 12.2.0
mips gcc 12.3.0
mips gcc 12.4.0
mips gcc 13.1.0
mips gcc 13.2.0
mips gcc 13.3.0
mips gcc 14.1.0
mips gcc 14.2.0
mips gcc 4.9.4
mips gcc 5.4
mips gcc 5.5.0
mips gcc 9.3.0 (codescape)
mips gcc 9.5.0
mips64 (el) gcc 12.1.0
mips64 (el) gcc 12.2.0
mips64 (el) gcc 12.3.0
mips64 (el) gcc 12.4.0
mips64 (el) gcc 13.1.0
mips64 (el) gcc 13.2.0
mips64 (el) gcc 13.3.0
mips64 (el) gcc 14.1.0
mips64 (el) gcc 14.2.0
mips64 (el) gcc 4.9.4
mips64 (el) gcc 5.4.0
mips64 (el) gcc 5.5.0
mips64 (el) gcc 9.5.0
mips64 clang 13.0.0
mips64 clang 14.0.0
mips64 clang 15.0.0
mips64 clang 16.0.0
mips64 clang 17.0.1
mips64 clang 18.1.0
mips64 clang 19.1.0
mips64 gcc 11.2.0
mips64 gcc 12.1.0
mips64 gcc 12.2.0
mips64 gcc 12.3.0
mips64 gcc 12.4.0
mips64 gcc 13.1.0
mips64 gcc 13.2.0
mips64 gcc 13.3.0
mips64 gcc 14.1.0
mips64 gcc 14.2.0
mips64 gcc 4.9.4
mips64 gcc 5.4.0
mips64 gcc 5.5.0
mips64 gcc 9.5.0
mips64el clang 13.0.0
mips64el clang 14.0.0
mips64el clang 15.0.0
mips64el clang 16.0.0
mips64el clang 17.0.1
mips64el clang 18.1.0
mips64el clang 19.1.0
mipsel clang 13.0.0
mipsel clang 14.0.0
mipsel clang 15.0.0
mipsel clang 16.0.0
mipsel clang 17.0.1
mipsel clang 18.1.0
mipsel clang 19.1.0
mipsel gcc 12.1.0
mipsel gcc 12.2.0
mipsel gcc 12.3.0
mipsel gcc 12.4.0
mipsel gcc 13.1.0
mipsel gcc 13.2.0
mipsel gcc 13.3.0
mipsel gcc 14.1.0
mipsel gcc 14.2.0
mipsel gcc 4.9.4
mipsel gcc 5.4.0
mipsel gcc 5.5.0
mipsel gcc 9.5.0
nanoMIPS gcc 6.3.0 (mtk)
power gcc 11.2.0
power gcc 12.1.0
power gcc 12.2.0
power gcc 12.3.0
power gcc 12.4.0
power gcc 13.1.0
power gcc 13.2.0
power gcc 13.3.0
power gcc 14.1.0
power gcc 14.2.0
power gcc 4.8.5
power64 AT12.0 (gcc8)
power64 AT13.0 (gcc9)
power64 gcc 11.2.0
power64 gcc 12.1.0
power64 gcc 12.2.0
power64 gcc 12.3.0
power64 gcc 12.4.0
power64 gcc 13.1.0
power64 gcc 13.2.0
power64 gcc 13.3.0
power64 gcc 14.1.0
power64 gcc 14.2.0
power64 gcc trunk
power64le AT12.0 (gcc8)
power64le AT13.0 (gcc9)
power64le clang (trunk)
power64le gcc 11.2.0
power64le gcc 12.1.0
power64le gcc 12.2.0
power64le gcc 12.3.0
power64le gcc 12.4.0
power64le gcc 13.1.0
power64le gcc 13.2.0
power64le gcc 13.3.0
power64le gcc 14.1.0
power64le gcc 14.2.0
power64le gcc 6.3.0
power64le gcc trunk
powerpc64 clang (trunk)
s390x gcc 11.2.0
s390x gcc 12.1.0
s390x gcc 12.2.0
s390x gcc 12.3.0
s390x gcc 12.4.0
s390x gcc 13.1.0
s390x gcc 13.2.0
s390x gcc 13.3.0
s390x gcc 14.1.0
s390x gcc 14.2.0
sh gcc 12.2.0
sh gcc 12.3.0
sh gcc 12.4.0
sh gcc 13.1.0
sh gcc 13.2.0
sh gcc 13.3.0
sh gcc 14.1.0
sh gcc 14.2.0
sh gcc 4.9.4
sh gcc 9.5.0
vast (trunk)
x64 msvc v19.0 (WINE)
x64 msvc v19.10 (WINE)
x64 msvc v19.14 (WINE)
x64 msvc v19.20 VS16.0
x64 msvc v19.21 VS16.1
x64 msvc v19.22 VS16.2
x64 msvc v19.23 VS16.3
x64 msvc v19.24 VS16.4
x64 msvc v19.25 VS16.5
x64 msvc v19.27 VS16.7
x64 msvc v19.28 VS16.8
x64 msvc v19.28 VS16.9
x64 msvc v19.29 VS16.10
x64 msvc v19.29 VS16.11
x64 msvc v19.30 VS17.0
x64 msvc v19.31 VS17.1
x64 msvc v19.32 VS17.2
x64 msvc v19.33 VS17.3
x64 msvc v19.34 VS17.4
x64 msvc v19.35 VS17.5
x64 msvc v19.36 VS17.6
x64 msvc v19.37 VS17.7
x64 msvc v19.38 VS17.8
x64 msvc v19.39 VS17.9
x64 msvc v19.40 VS17.10
x64 msvc v19.latest
x86 djgpp 4.9.4
x86 djgpp 5.5.0
x86 djgpp 6.4.0
x86 djgpp 7.2.0
x86 msvc v19.0 (WINE)
x86 msvc v19.10 (WINE)
x86 msvc v19.14 (WINE)
x86 msvc v19.20 VS16.0
x86 msvc v19.21 VS16.1
x86 msvc v19.22 VS16.2
x86 msvc v19.23 VS16.3
x86 msvc v19.24 VS16.4
x86 msvc v19.25 VS16.5
x86 msvc v19.27 VS16.7
x86 msvc v19.28 VS16.8
x86 msvc v19.28 VS16.9
x86 msvc v19.29 VS16.10
x86 msvc v19.29 VS16.11
x86 msvc v19.30 VS17.0
x86 msvc v19.31 VS17.1
x86 msvc v19.32 VS17.2
x86 msvc v19.33 VS17.3
x86 msvc v19.34 VS17.4
x86 msvc v19.35 VS17.5
x86 msvc v19.36 VS17.6
x86 msvc v19.37 VS17.7
x86 msvc v19.38 VS17.8
x86 msvc v19.39 VS17.9
x86 msvc v19.40 VS17.10
x86 msvc v19.latest
x86 nvc++ 22.11
x86 nvc++ 22.7
x86 nvc++ 22.9
x86 nvc++ 23.1
x86 nvc++ 23.11
x86 nvc++ 23.3
x86 nvc++ 23.5
x86 nvc++ 23.7
x86 nvc++ 23.9
x86 nvc++ 24.1
x86 nvc++ 24.3
x86 nvc++ 24.5
x86 nvc++ 24.7
x86-64 Zapcc 190308
x86-64 clang (EricWF contracts)
x86-64 clang (amd-staging)
x86-64 clang (assertions trunk)
x86-64 clang (clangir)
x86-64 clang (dascandy contracts)
x86-64 clang (experimental -Wlifetime)
x86-64 clang (experimental P1061)
x86-64 clang (experimental P1144)
x86-64 clang (experimental P1221)
x86-64 clang (experimental P2996)
x86-64 clang (experimental P3068)
x86-64 clang (experimental P3309)
x86-64 clang (experimental P3367)
x86-64 clang (experimental P3372)
x86-64 clang (experimental metaprogramming - P2632)
x86-64 clang (old concepts branch)
x86-64 clang (p1974)
x86-64 clang (pattern matching - P2688)
x86-64 clang (reflection)
x86-64 clang (resugar)
x86-64 clang (thephd.dev)
x86-64 clang (trunk)
x86-64 clang (variadic friends - P2893)
x86-64 clang (widberg)
x86-64 clang 10.0.0
x86-64 clang 10.0.0 (assertions)
x86-64 clang 10.0.1
x86-64 clang 11.0.0
x86-64 clang 11.0.0 (assertions)
x86-64 clang 11.0.1
x86-64 clang 12.0.0
x86-64 clang 12.0.0 (assertions)
x86-64 clang 12.0.1
x86-64 clang 13.0.0
x86-64 clang 13.0.0 (assertions)
x86-64 clang 13.0.1
x86-64 clang 14.0.0
x86-64 clang 14.0.0 (assertions)
x86-64 clang 15.0.0
x86-64 clang 15.0.0 (assertions)
x86-64 clang 16.0.0
x86-64 clang 16.0.0 (assertions)
x86-64 clang 17.0.1
x86-64 clang 17.0.1 (assertions)
x86-64 clang 18.1.0
x86-64 clang 18.1.0 (assertions)
x86-64 clang 19.1.0
x86-64 clang 19.1.0 (assertions)
x86-64 clang 2.6.0 (assertions)
x86-64 clang 2.7.0 (assertions)
x86-64 clang 2.8.0 (assertions)
x86-64 clang 2.9.0 (assertions)
x86-64 clang 3.0.0
x86-64 clang 3.0.0 (assertions)
x86-64 clang 3.1
x86-64 clang 3.1 (assertions)
x86-64 clang 3.2
x86-64 clang 3.2 (assertions)
x86-64 clang 3.3
x86-64 clang 3.3 (assertions)
x86-64 clang 3.4 (assertions)
x86-64 clang 3.4.1
x86-64 clang 3.5
x86-64 clang 3.5 (assertions)
x86-64 clang 3.5.1
x86-64 clang 3.5.2
x86-64 clang 3.6
x86-64 clang 3.6 (assertions)
x86-64 clang 3.7
x86-64 clang 3.7 (assertions)
x86-64 clang 3.7.1
x86-64 clang 3.8
x86-64 clang 3.8 (assertions)
x86-64 clang 3.8.1
x86-64 clang 3.9.0
x86-64 clang 3.9.0 (assertions)
x86-64 clang 3.9.1
x86-64 clang 4.0.0
x86-64 clang 4.0.0 (assertions)
x86-64 clang 4.0.1
x86-64 clang 5.0.0
x86-64 clang 5.0.0 (assertions)
x86-64 clang 5.0.1
x86-64 clang 5.0.2
x86-64 clang 6.0.0
x86-64 clang 6.0.0 (assertions)
x86-64 clang 6.0.1
x86-64 clang 7.0.0
x86-64 clang 7.0.0 (assertions)
x86-64 clang 7.0.1
x86-64 clang 7.1.0
x86-64 clang 8.0.0
x86-64 clang 8.0.0 (assertions)
x86-64 clang 8.0.1
x86-64 clang 9.0.0
x86-64 clang 9.0.0 (assertions)
x86-64 clang 9.0.1
x86-64 clang rocm-4.5.2
x86-64 clang rocm-5.0.2
x86-64 clang rocm-5.1.3
x86-64 clang rocm-5.2.3
x86-64 clang rocm-5.3.3
x86-64 clang rocm-5.7.0
x86-64 clang rocm-6.0.2
x86-64 clang rocm-6.1.2
x86-64 gcc (contract labels)
x86-64 gcc (contracts natural syntax)
x86-64 gcc (contracts)
x86-64 gcc (coroutines)
x86-64 gcc (modules)
x86-64 gcc (trunk)
x86-64 gcc 10.1
x86-64 gcc 10.2
x86-64 gcc 10.3
x86-64 gcc 10.4
x86-64 gcc 10.5
x86-64 gcc 11.1
x86-64 gcc 11.2
x86-64 gcc 11.3
x86-64 gcc 11.4
x86-64 gcc 12.1
x86-64 gcc 12.2
x86-64 gcc 12.3
x86-64 gcc 12.4
x86-64 gcc 13.1
x86-64 gcc 13.2
x86-64 gcc 13.3
x86-64 gcc 14.1
x86-64 gcc 14.2
x86-64 gcc 3.4.6
x86-64 gcc 4.0.4
x86-64 gcc 4.1.2
x86-64 gcc 4.4.7
x86-64 gcc 4.5.3
x86-64 gcc 4.6.4
x86-64 gcc 4.7.1
x86-64 gcc 4.7.2
x86-64 gcc 4.7.3
x86-64 gcc 4.7.4
x86-64 gcc 4.8.1
x86-64 gcc 4.8.2
x86-64 gcc 4.8.3
x86-64 gcc 4.8.4
x86-64 gcc 4.8.5
x86-64 gcc 4.9.0
x86-64 gcc 4.9.1
x86-64 gcc 4.9.2
x86-64 gcc 4.9.3
x86-64 gcc 4.9.4
x86-64 gcc 5.1
x86-64 gcc 5.2
x86-64 gcc 5.3
x86-64 gcc 5.4
x86-64 gcc 5.5
x86-64 gcc 6.1
x86-64 gcc 6.2
x86-64 gcc 6.3
x86-64 gcc 6.4
x86-64 gcc 6.5
x86-64 gcc 7.1
x86-64 gcc 7.2
x86-64 gcc 7.3
x86-64 gcc 7.4
x86-64 gcc 7.5
x86-64 gcc 8.1
x86-64 gcc 8.2
x86-64 gcc 8.3
x86-64 gcc 8.4
x86-64 gcc 8.5
x86-64 gcc 9.1
x86-64 gcc 9.2
x86-64 gcc 9.3
x86-64 gcc 9.4
x86-64 gcc 9.5
x86-64 icc 13.0.1
x86-64 icc 16.0.3
x86-64 icc 17.0.0
x86-64 icc 18.0.0
x86-64 icc 19.0.0
x86-64 icc 19.0.1
x86-64 icc 2021.1.2
x86-64 icc 2021.10.0
x86-64 icc 2021.2.0
x86-64 icc 2021.3.0
x86-64 icc 2021.4.0
x86-64 icc 2021.5.0
x86-64 icc 2021.6.0
x86-64 icc 2021.7.0
x86-64 icc 2021.7.1
x86-64 icc 2021.8.0
x86-64 icc 2021.9.0
x86-64 icx (latest)
x86-64 icx 2021.1.2
x86-64 icx 2021.2.0
x86-64 icx 2021.3.0
x86-64 icx 2021.4.0
x86-64 icx 2022.0.0
x86-64 icx 2022.1.0
x86-64 icx 2022.2.0
x86-64 icx 2022.2.1
x86-64 icx 2023.0.0
x86-64 icx 2023.1.0
x86-64 icx 2023.2.1
x86-64 icx 2024.0.0
x86-64 icx 2024.1.0
x86-64 icx 2024.2.0
zig c++ 0.10.0
zig c++ 0.11.0
zig c++ 0.12.0
zig c++ 0.12.1
zig c++ 0.13.0
zig c++ 0.6.0
zig c++ 0.7.0
zig c++ 0.7.1
zig c++ 0.8.0
zig c++ 0.9.0
zig c++ trunk
Options
Source code
// 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_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_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 >= 201304 && \ !(defined(_MSC_VER) && _MSC_VER <= 1915) #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 #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(...) -> 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 <typename T, bool = is_swappable<T>::value> struct is_nothrow_swappable { static constexpr bool value = noexcept(swap(std::declval<T &>(), std::declval<T &>())); }; template <typename T> struct is_nothrow_swappable<T, false> : std::false_type {}; } // namespace swappable } // namespace detail using detail::swappable::is_swappable; using detail::swappable::is_nothrow_swappable; // <functional> #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4100) #endif template <typename F, typename... As> inline constexpr auto invoke(F &&f, As &&... as) MPARK_RETURN(lib::forward<F>(f)(lib::forward<As>(as)...)) #ifdef _MSC_VER #pragma warning(pop) #endif template <typename B, typename T, typename D> inline constexpr auto invoke(T B::*pmv, D &&d) MPARK_RETURN(lib::forward<D>(d).*pmv) template <typename Pmv, typename Ptr> inline constexpr auto invoke(Pmv pmv, Ptr &&ptr) MPARK_RETURN((*lib::forward<Ptr>(ptr)).*pmv) template <typename B, typename T, typename D, typename... As> inline constexpr auto invoke(T B::*pmf, D &&d, As &&... as) MPARK_RETURN((lib::forward<D>(d).*pmf)(lib::forward<As>(as)...)) template <typename Pmf, typename Ptr, typename... As> inline constexpr auto invoke(Pmf pmf, Ptr &&ptr, As &&... as) MPARK_RETURN(((*lib::forward<Ptr>(ptr)).*pmf)(lib::forward<As>(as)...)) 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...>; // <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 {}; } // 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; for (Trait t : {traits...}) { 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) AUTO_REFREF_RETURN(recursive_union::get_alt( data(lib::forward<V>(v)), in_place_index_t<I>{})) }; 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 { struct base { template <bool B, typename R, typename... ITs> struct dispatcher; template <typename R, typename... ITs> struct dispatcher<false, R, ITs...> { #ifdef MPARK_CPP14_CONSTEXPR template <std::size_t B, typename F, typename... Vs> [[noreturn]] static constexpr R dispatch(F &&, typename ITs::type &&..., Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } template <std::size_t I, typename F, typename... Vs> [[noreturn]] static constexpr R dispatch_case(F &&, Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } template <std::size_t B, typename F, typename... Vs> [[noreturn]] static constexpr R dispatch_at(std::size_t, F &&, Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } #else template <std::size_t B, typename F, typename... Vs> [[noreturn]] static R dispatch(F &&, typename ITs::type &&..., Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } template <std::size_t I, typename F, typename... Vs> [[noreturn]] static R dispatch_case(F &&, Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } template <std::size_t B, typename F, typename... Vs> [[noreturn]] static R dispatch_at(std::size_t, F &&, Vs &&...) { MPARK_BUILTIN_UNREACHABLE; } #endif }; template <typename R, typename... ITs> struct dispatcher<true, R, ITs...> { template <std::size_t B, typename F> [[gnu::always_inline]] static constexpr R dispatch( F &&f, typename ITs::type &&... visited_vs) { return lib::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> [[gnu::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)...) #ifdef MPARK_CPP14_CONSTEXPR 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); } #else return v.index() == B + 0 ? MPARK_DISPATCH(B + 0) : v.index() == B + 1 ? MPARK_DISPATCH(B + 1) : v.index() == B + 2 ? MPARK_DISPATCH(B + 2) : v.index() == B + 3 ? MPARK_DISPATCH(B + 3) : v.index() == B + 4 ? MPARK_DISPATCH(B + 4) : v.index() == B + 5 ? MPARK_DISPATCH(B + 5) : v.index() == B + 6 ? MPARK_DISPATCH(B + 6) : v.index() == B + 7 ? MPARK_DISPATCH(B + 7) : v.index() == B + 8 ? MPARK_DISPATCH(B + 8) : v.index() == B + 9 ? MPARK_DISPATCH(B + 9) : v.index() == B + 10 ? MPARK_DISPATCH(B + 10) : v.index() == B + 11 ? MPARK_DISPATCH(B + 11) : v.index() == B + 12 ? MPARK_DISPATCH(B + 12) : v.index() == B + 13 ? MPARK_DISPATCH(B + 13) : v.index() == B + 14 ? MPARK_DISPATCH(B + 14) : v.index() == B + 15 ? MPARK_DISPATCH(B + 15) : v.index() == B + 16 ? MPARK_DISPATCH(B + 16) : v.index() == B + 17 ? MPARK_DISPATCH(B + 17) : v.index() == B + 18 ? MPARK_DISPATCH(B + 18) : v.index() == B + 19 ? MPARK_DISPATCH(B + 19) : v.index() == B + 20 ? MPARK_DISPATCH(B + 20) : v.index() == B + 21 ? MPARK_DISPATCH(B + 21) : v.index() == B + 22 ? MPARK_DISPATCH(B + 22) : v.index() == B + 23 ? MPARK_DISPATCH(B + 23) : v.index() == B + 24 ? MPARK_DISPATCH(B + 24) : v.index() == B + 25 ? MPARK_DISPATCH(B + 25) : v.index() == B + 26 ? MPARK_DISPATCH(B + 26) : v.index() == B + 27 ? MPARK_DISPATCH(B + 27) : v.index() == B + 28 ? MPARK_DISPATCH(B + 28) : v.index() == B + 29 ? MPARK_DISPATCH(B + 29) : v.index() == B + 30 ? MPARK_DISPATCH(B + 30) : v.index() == B + 31 ? MPARK_DISPATCH(B + 31) : MPARK_DEFAULT(B + 32); #endif #undef MPARK_DEFAULT #undef MPARK_DISPATCH } template <std::size_t I, typename F, typename... Vs> static constexpr R dispatch_case(F &&f, Vs &&... vs) { return lib::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> 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)...) #ifdef MPARK_CPP14_CONSTEXPR 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); } #else return index == B + 0 ? MPARK_DISPATCH_AT(B + 0) : index == B + 1 ? MPARK_DISPATCH_AT(B + 1) : index == B + 2 ? MPARK_DISPATCH_AT(B + 2) : index == B + 3 ? MPARK_DISPATCH_AT(B + 3) : index == B + 4 ? MPARK_DISPATCH_AT(B + 4) : index == B + 5 ? MPARK_DISPATCH_AT(B + 5) : index == B + 6 ? MPARK_DISPATCH_AT(B + 6) : index == B + 7 ? MPARK_DISPATCH_AT(B + 7) : index == B + 8 ? MPARK_DISPATCH_AT(B + 8) : index == B + 9 ? MPARK_DISPATCH_AT(B + 9) : index == B + 10 ? MPARK_DISPATCH_AT(B + 10) : index == B + 11 ? MPARK_DISPATCH_AT(B + 11) : index == B + 12 ? MPARK_DISPATCH_AT(B + 12) : index == B + 13 ? MPARK_DISPATCH_AT(B + 13) : index == B + 14 ? MPARK_DISPATCH_AT(B + 14) : index == B + 15 ? MPARK_DISPATCH_AT(B + 15) : index == B + 16 ? MPARK_DISPATCH_AT(B + 16) : index == B + 17 ? MPARK_DISPATCH_AT(B + 17) : index == B + 18 ? MPARK_DISPATCH_AT(B + 18) : index == B + 19 ? MPARK_DISPATCH_AT(B + 19) : index == B + 20 ? MPARK_DISPATCH_AT(B + 20) : index == B + 21 ? MPARK_DISPATCH_AT(B + 21) : index == B + 22 ? MPARK_DISPATCH_AT(B + 22) : index == B + 23 ? MPARK_DISPATCH_AT(B + 23) : index == B + 24 ? MPARK_DISPATCH_AT(B + 24) : index == B + 25 ? MPARK_DISPATCH_AT(B + 25) : index == B + 26 ? MPARK_DISPATCH_AT(B + 26) : index == B + 27 ? MPARK_DISPATCH_AT(B + 27) : index == B + 28 ? MPARK_DISPATCH_AT(B + 28) : index == B + 29 ? MPARK_DISPATCH_AT(B + 29) : index == B + 30 ? MPARK_DISPATCH_AT(B + 30) : index == B + 31 ? MPARK_DISPATCH_AT(B + 31) : MPARK_DEFAULT(B + 32); #endif #undef MPARK_DEFAULT #undef MPARK_DISPATCH_AT } }; }; // namespace base struct alt { template <typename Visitor, typename... Vs> inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor, Vs &&... vs) DECLTYPE_AUTO_RETURN( base::dispatcher<true, decltype( lib::invoke(lib::forward<Visitor>(visitor), access::base::get_alt<0>( lib::forward<Vs>(vs))...))>:: template dispatch<0>(lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...)) template <typename Visitor, typename... Vs> inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index, Visitor &&visitor, Vs &&... vs) DECLTYPE_AUTO_RETURN( base::dispatcher<true, decltype( lib::invoke(lib::forward<Visitor>(visitor), access::base::get_alt<0>( lib::forward<Vs>(vs))...))>:: template dispatch_at<0>(index, lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...)) }; struct variant { private: template <typename Visitor, typename... Values> struct visit_exhaustive_visitor_check { static_assert( lib::is_invocable<Visitor, Values...>::value, "`mpark::visit` requires the visitor to be exhaustive."); #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4100) #endif inline constexpr DECLTYPE_AUTO operator()(Visitor &&visitor, Values &&... values) const DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor), lib::forward<Values>(values)...)) #ifdef _MSC_VER #pragma warning(pop) #endif }; template <typename Visitor> struct value_visitor { Visitor &&visitor_; template <typename... Alts> inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const DECLTYPE_AUTO_RETURN( visit_exhaustive_visitor_check< Visitor, decltype((lib::forward<Alts>(alts).value))...>{}( 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) \ template <typename... Args> \ inline explicit constexpr type(Args &&... args) \ : base(lib::forward<Args>(args)...) {} #else #define MPARK_INHERITING_CTOR(type, base) using base::base; #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) { ::new (static_cast<void *>(lib::addressof(a))) alt<I, T>(in_place_t{}, lib::forward<Args>(args)...); return a.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 // 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 LIB_HPP #define LIB_HPP namespace lib { #ifdef __cpp_lib_integer_sequence using std::index_sequence; using std::index_sequence_for; using std::integer_sequence; using std::make_index_sequence; #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...>> { using type = 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> { using type = index_sequence<>; }; template <> struct make_index_sequence_impl<1> { using type = index_sequence<0>; }; #endif } // namespace lib #endif // LIB_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) #include <benchmark/benchmark.h> #include <cstddef> #include <type_traits> #include <vector> template <std::size_t I> using size_constant = std::integral_constant<std::size_t, I>; template <std::size_t... Is> using variants = std::vector<mpark::variant<size_constant<Is>...>>; template <std::size_t... Is> variants<Is...> make_variants(lib::index_sequence<Is...>) { variants<Is...> vs; for (std::size_t i = 0; i < 5000 / sizeof...(Is); ++i) { int dummy[] = {(vs.push_back(size_constant<Is>{}), 0)...}; (void)dummy; } return vs; } struct visitor { template <std::size_t I> constexpr std::size_t operator()(size_constant<I>) const { return I; } }; template <std::size_t N> static void visit1(benchmark::State &state) { auto vs = make_variants(lib::make_index_sequence<N>{}); for (auto _ : state) { int sum = 0; for (const auto &v : vs) { sum += mpark::visit(visitor{}, v); } benchmark::DoNotOptimize(sum); } } BENCHMARK_TEMPLATE(visit1, 8);
Become a Patron
Sponsor on GitHub
Donate via PayPal
Source on GitHub
Mailing list
Installed libraries
Wiki
Report an issue
How it works
Contact the author
CE on Mastodon
About the author
Statistics
Changelog
Version tree