Showing preview only (2,283K chars total). Download the full file or copy to clipboard to get everything.
Repository: penn-graphics-research/claymore
Branch: master
Commit: 3b19462f1589
Files: 183
Total size: 2.1 MB
Directory structure:
gitextract_mlo6v1x3/
├── .clang-format
├── .clang-tidy
├── .gitignore
├── .gitmodules
├── CMake/
│ ├── DownloadProject.CMakeLists.cmake.in
│ ├── DownloadProject.LICENSE
│ ├── DownloadProject.cmake
│ ├── FindWayland.cmake
│ └── FindXCB.cmake
├── CMake-Utils/
│ ├── setup_cpp.cmake
│ ├── setup_cuda.cmake
│ ├── setup_externallibs.cmake
│ └── setup_python.cmake
├── CMakeLists.txt
├── Externals/
│ ├── CMakeLists.txt
│ ├── SDFGen/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── array1.h
│ │ ├── array2.h
│ │ ├── array3.h
│ │ ├── config.h.in
│ │ ├── hashgrid.h
│ │ ├── hashtable.h
│ │ ├── main.cpp
│ │ ├── makelevelset3.cpp
│ │ ├── makelevelset3.h
│ │ ├── util.h
│ │ └── vec.h
│ ├── function_ref/
│ │ └── tl/
│ │ └── function_ref.hpp
│ ├── optional/
│ │ └── tl/
│ │ └── optional.hpp
│ ├── partio/
│ │ ├── CMakeLists.txt
│ │ ├── Partio.h
│ │ ├── PartioAttribute.h
│ │ ├── PartioIterator.h
│ │ ├── PartioVec3.h
│ │ ├── core/
│ │ │ ├── KdTree.h
│ │ │ ├── Mutex.h
│ │ │ ├── Particle.cpp
│ │ │ ├── ParticleCaching.cpp
│ │ │ ├── ParticleCaching.h
│ │ │ ├── ParticleHeaders.cpp
│ │ │ ├── ParticleHeaders.h
│ │ │ ├── ParticleSimple.cpp
│ │ │ ├── ParticleSimple.h
│ │ │ ├── ParticleSimpleInterleave.cpp
│ │ │ └── ParticleSimpleInterleave.h
│ │ └── io/
│ │ ├── BGEO.cpp
│ │ ├── BIN.cpp
│ │ ├── GEO.cpp
│ │ ├── MC.cpp
│ │ ├── PDA.cpp
│ │ ├── PDB.cpp
│ │ ├── PDC.cpp
│ │ ├── PRT.cppbak
│ │ ├── PTC.cpp
│ │ ├── PTS.cpp
│ │ ├── ParticleIO.cpp
│ │ ├── PartioEndian.h
│ │ ├── RIB.cpp
│ │ ├── ZIP.cpp
│ │ ├── ZIP.h
│ │ ├── half2float.h
│ │ ├── pdb.h
│ │ └── readers.h
│ └── variant/
│ └── mpark/
│ ├── config.hpp
│ ├── in_place.hpp
│ ├── lib.hpp
│ └── variant.hpp
├── LICENSE
├── Library/
│ ├── CMakeLists.txt
│ ├── MnBase/
│ │ ├── Algorithm/
│ │ │ ├── MappingKernels.cuh
│ │ │ ├── ParallelPatterns.cuh
│ │ │ └── SortKernels.cuh
│ │ ├── Concurrency/
│ │ │ └── Concurrency.h
│ │ ├── DataStructure/
│ │ │ ├── Bvh/
│ │ │ │ └── Bvh.cuh
│ │ │ ├── FSM/
│ │ │ │ └── FiniteStateMachine.h
│ │ │ └── Hash/
│ │ │ └── Hash.cuh
│ │ ├── Geometry/
│ │ │ └── GeometrySampler.h
│ │ ├── Math/
│ │ │ ├── Bit/
│ │ │ │ ├── Bits.h
│ │ │ │ └── SpatialEncoder.cuh
│ │ │ ├── Matrix/
│ │ │ │ ├── EigenDecomposition.cuh
│ │ │ │ ├── Givens.cuh
│ │ │ │ ├── MatrixKernels.cuh
│ │ │ │ ├── MatrixUtils.h
│ │ │ │ ├── Utility.h
│ │ │ │ ├── qr.cuh
│ │ │ │ └── svd.cuh
│ │ │ ├── Probability/
│ │ │ │ ├── Probability.cpp
│ │ │ │ └── Probability.h
│ │ │ └── Vec.h
│ │ ├── Memory/
│ │ │ ├── Allocator.h
│ │ │ ├── MemObj.h
│ │ │ └── MemoryResource.h
│ │ ├── Meta/
│ │ │ ├── AllocMeta.cuh
│ │ │ ├── ControlFlow.h
│ │ │ ├── Functional.h
│ │ │ ├── MathMeta.h
│ │ │ ├── Meta.h
│ │ │ ├── Optional.h
│ │ │ ├── PatternMeta.h
│ │ │ ├── Polymorphism.h
│ │ │ ├── Relationship.h
│ │ │ ├── TupleMeta.h
│ │ │ ├── TypeDecoration.h
│ │ │ ├── TypeIdentity.h
│ │ │ ├── TypeMeta.h
│ │ │ ├── TypeOperation.h
│ │ │ └── TypeProperty.h
│ │ ├── Object/
│ │ │ ├── Function.h
│ │ │ ├── Property.h
│ │ │ ├── Structural.h
│ │ │ ├── StructuralAuxiliary.h
│ │ │ └── StructuralDeclaration.h
│ │ ├── Profile/
│ │ │ ├── CppTimers.hpp
│ │ │ └── CudaTimers.cuh
│ │ ├── Reflection.h
│ │ └── Singleton.h
│ └── MnSystem/
│ ├── CMakeLists.txt
│ ├── Cuda/
│ │ ├── Allocators.cuh
│ │ ├── Cuda.cu
│ │ ├── Cuda.h
│ │ ├── DeviceUtils.cu
│ │ ├── DeviceUtils.cuh
│ │ ├── ExecutionPolicy.h
│ │ ├── HostUtils.hpp
│ │ ├── KernelLauncher.cuh
│ │ ├── MemoryUtils.cu
│ │ └── MemoryUtils.cuh
│ ├── IO/
│ │ ├── IO.cpp
│ │ ├── IO.h
│ │ ├── ParticleIO.hpp
│ │ └── PoissonDisk/
│ │ ├── PoissonDisk.h
│ │ ├── SampleGenerator.h
│ │ ├── cyCore.h
│ │ ├── cyHeap.h
│ │ ├── cyPoint.h
│ │ ├── cyPointCloud.h
│ │ └── cySampleElim.h
│ └── sourcelist.cmake
├── Projects/
│ ├── CMakeLists.txt
│ ├── GMPM/
│ │ ├── CMakeLists.txt
│ │ ├── constitutive_models.cuh
│ │ ├── gmpm.cu
│ │ ├── gmpm_simulator.cuh
│ │ ├── grid_buffer.cuh
│ │ ├── hash_table.cuh
│ │ ├── mgmpm_kernels.cuh
│ │ ├── particle_buffer.cuh
│ │ ├── partition_domain.h
│ │ ├── scenes/
│ │ │ └── scene.json
│ │ ├── settings.h
│ │ └── utility_funcs.hpp
│ ├── MGSP/
│ │ ├── CMakeLists.txt
│ │ ├── boundary_condition.cuh
│ │ ├── constitutive_models.cuh
│ │ ├── grid_buffer.cuh
│ │ ├── halo_buffer.cuh
│ │ ├── halo_kernels.cuh
│ │ ├── hash_table.cuh
│ │ ├── mgmpm_kernels.cuh
│ │ ├── mgsp.cu
│ │ ├── mgsp_benchmark.cuh
│ │ ├── particle_buffer.cuh
│ │ ├── partition_domain.h
│ │ ├── settings.h
│ │ └── utility_funcs.hpp
│ └── TaichiScripts/
│ └── gmpm.py
├── README.md
├── docs/
│ ├── benchmark.rst
│ ├── compilation.rst
│ ├── conf.py
│ ├── credits.rst
│ ├── datastructure.rst
│ ├── index.rst
│ ├── multigmpm.rst
│ ├── overview.rst
│ ├── philosophy.rst
│ ├── pipeline.rst
│ ├── sparsity.rst
│ ├── structural.rst
│ ├── system.rst
│ └── usage.rst
└── project_info.in
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
Language: Cpp # Maybe change
Standard: Auto # Maybe change
BasedOnStyle: Google # Maybe change
AlignAfterOpenBracket: BlockIndent # Better overview
AlignArrayOfStructures: Right # Better overview (but might make editing harder)
AlignConsecutiveAssignments: true # Better overview (but might make editing harder)
AlignConsecutiveBitFields: true # Better overview (but might make editing harder)
AlignConsecutiveDeclarations: false # Better Overview, as otherwise we would separate a identifier from its type
AlignEscapedNewlines: Left # Better Overview
AlignOperands: AlignAfterOperator # Better overview
AlignTrailingComments:
Kind: Always # Better overview
AllowAllArgumentsOnNextLine: false # Better overview
AllowAllParametersOfDeclarationOnNextLine: false # Better overview
AllowShortBlocksOnASingleLine: Empty # Better overview
AllowShortCaseLabelsOnASingleLine: false # Better overview
AllowShortEnumsOnASingleLine: false # Better overview
AllowShortFunctionsOnASingleLine: Empty # Better overview
AllowShortIfStatementsOnASingleLine: Never # Better overview
AllowShortLambdasOnASingleLine: Empty # Better overview
AllowShortLoopsOnASingleLine: false # Better overview
AlwaysBreakAfterReturnType: None # Don't produce an unnecessary empty line
AlwaysBreakBeforeMultilineStrings: true # Better overview
AlwaysBreakTemplateDeclarations: Yes # Better overview
BinPackArguments: false # Better overview
BinPackParameters: false # Better overview
BitFieldColonSpacing: Both # Better overview
BraceWrapping:
AfterCaseLabel: false # Don't produce an unnecessary empty line
AfterClass: false # Don't produce an unnecessary empty line
AfterControlStatement: Never # Don't produce an unnecessary empty line
AfterEnum: false # Don't produce an unnecessary empty line
AfterFunction: false # Don't produce an unnecessary empty line
AfterNamespace: false # Don't produce an unnecessary empty line
AfterObjCDeclaration: false # Don't produce an unnecessary empty line
AfterStruct: false # Don't produce an unnecessary empty line
AfterUnion: false # Don't produce an unnecessary empty line
AfterExternBlock: false # Don't produce an unnecessary empty line
BeforeCatch: false # Don't produce an unnecessary empty line
BeforeElse: false # Don't produce an unnecessary empty line
BeforeLambdaBody: false # Don't produce an unnecessary empty line
BeforeWhile: false # Don't produce an unnecessary empty line
IndentBraces: false # Don't produce an unnecessary empty line
SplitEmptyFunction: false # Don't produce an unnecessary empty line
SplitEmptyRecord: false # Don't produce an unnecessary empty line
SplitEmptyNamespace: false # Don't produce an unnecessary empty line
BreakAfterAttributes: Never # Don't produce an unnecessary empty line
BreakBeforeBinaryOperators: NonAssignment # Allows easier out-commenting of single parts of assignments
BreakBeforeBraces: Attach # Don't produce an unnecessary empty line
BreakBeforeConceptDeclarations: true # Better overview
BreakBeforeTernaryOperators: true # Better overview
BreakConstructorInitializers: BeforeComma # Better overview and easier out-commenting of single initializers
BreakInheritanceList: BeforeComma # Better overview and easier out-commenting of base classes
BreakStringLiterals: false # Avoid config-based wrapping of strings (as it actually depends on the users screen size how wrapping should be applied)
ColumnLimit: 1000 # No limit (use high number to enforce removal of existing breaks); Avoid config-based wrapping of strings (as it actually depends on the users screen size how wrapping should be applied)
CompactNamespaces: false # Better overview
Cpp11BracedListStyle: true # Better overview
DeriveLineEnding: false # Formatting should be fixed, not derived
DerivePointerAlignment: false # Formatting should be fixed, not derived
EmptyLineAfterAccessModifier: Never # Don't produce an unnecessary empty line
EmptyLineBeforeAccessModifier: Always # Here empty lines help overview, as they clearly make the current access modifier more visible
FixNamespaceComments: true # Better overview
IncludeBlocks: Regroup # Better overview
IndentAccessModifiers: false # As members will be intended, this separates access modifiers from members more clearly
IndentCaseBlocks: false # We don't wrap braces here, so intend would move closing brace out of vertical line
IndentCaseLabels: true # Better overview, as it's visible, that case is inside switch
IndentExternBlock: Indent # Better overview
IndentGotoLabels: true # Better overview, as otherwise e.gt breaks would break out intendation
IndentPPDirectives: AfterHash # Better overview, as hash tag still marks post processing, but the directives are intended
IndentRequiresClause: false #Intend would break statement out of vertical line
IndentWidth: 4 # Make tab indentation work
IndentWrappedFunctionNames: true # Better overview, as the breaking of function name is marked
InsertBraces: false # Done by clang-tidy #Better overview and maintaining of code, as additional statements can be easily added. WARNING: May break code. Better directly avoid clauses without braces
KeepEmptyLinesAtTheStartOfBlocks: false # Remove an unnecessary empty line
LambdaBodyIndentation: Signature # Better overview
NamespaceIndentation: Inner # Avoid having most of the code intended if we have a big namespace
PackConstructorInitializers: Never # Better overview
PointerAlignment: Left # Better overview, as star is part of the type
QualifierAlignment: Leave # clang-format is not able to handle this without breaking code
ReferenceAlignment: Left # Better overview, as ampersand is part of the type
ReflowComments: false # I don't know, what clang-format is doing here, but it looks bad: Avoid config-based wrapping of strings (as it actually depends on the users screen size how wrapping should be applied)
RequiresClausePosition: OwnLine # Better overview
RequiresExpressionIndentation: OuterScope # Better overview
SeparateDefinitionBlocks: Leave # Allow user to specify that on his own. May be used to group some blocks together that belong together, while separating other blocks
ShortNamespaceLines: 0 # Better overview, as namespaces are clearly marked by closing comment and opening statement
SortIncludes: CaseSensitive # Better overview. TODO: Maybe change that if it causes problems
SortUsingDeclarations: true # Better overview. TODO: Maybe change that if it causes problems
SpaceAfterCStyleCast: true # Better overview
SpaceAfterLogicalNot: false # Avoid unnecessary space, cause actually the unary operator belongs to the identifier
SpaceAfterTemplateKeyword: false # Space would separate template from it's parameters
SpaceAroundPointerQualifiers: Default # Don't known why we should change this. TODO: Reevaluate?
SpaceBeforeAssignmentOperators: true # Better overview, as we separate identifier from operator
SpaceBeforeCaseColon: false # Avoid unnecessary space
SpaceBeforeCpp11BracedList: true # Better overview
SpaceBeforeCtorInitializerColon: true # Better overview, as we mark more clearly, where initializer list starts
SpaceBeforeInheritanceColon: true # Better overview, as we mark more clearly, where base class list starts
SpaceBeforeParens: Never # Avoid unnecessary space
SpaceBeforeRangeBasedForLoopColon: false # Avoid unnecessary space
SpaceBeforeSquareBrackets: false # Avoid unnecessary space
SpaceInEmptyBlock: false # Avoid unnecessary space
SpaceInEmptyParentheses: false # Avoid unnecessary space
SpacesBeforeTrailingComments: 0 # Avoid unnecessary space
SpacesInAngles: Never # Avoid unnecessary space
SpacesInCStyleCastParentheses: false # Avoid unnecessary space
SpacesInConditionalStatement: false # Avoid unnecessary space
SpacesInParentheses: false # Avoid unnecessary space
SpacesInSquareBrackets: false # Avoid unnecessary space
TabWidth: 4 # Make tab indentation work
UseCRLF: true # Better compatibility
UseTab: Always # Use tabs where we can
================================================
FILE: .clang-tidy
================================================
# abseil-cleanup-ctad Avoid doubled printing of type
# abseil-duration-addition Ensure explicit use of correct duration type
# abseil-duration-comparison Ensure explicit use of correct duration type
# abseil-duration-conversion-cast Ensure correct cast of durations
# abseil-duration-division Ensure explicit use of correct duration division
# abseil-duration-factory-float Avoid use of inperformant conversion funnctions
# abseil-duration-factory-scale Avoid use of wrong scale conversion funnctions
# abseil-duration-subtraction Ensure explicit use of correct duration type
# abseil-duration-unnecessary-conversion Avoid unnecessary conversion
# abseil-faster-strsplit-delimiter Avoid inperformant use of Strings when Characters are suggested
#xabseil-no-internal-dependencies Not used, cause use of internal details is probably intended when found
#xabseil-no-namespace Not used, cause use of namespace is probably intended when found
# abseil-redundant-strcat-calls Avoid unnecessary function calls
# abseil-str-cat-append Avoid concatination when appending is suggested
# abseil-string-find-startswith Ensure std::string::startsWith is called instead of find-functions
#xabseil-string-find-str-contains Not used, cause it suggests usage of abseil functions instead of standard library functions
# abseil-time-comparison Ensure explicit use of time type when comnparing times
# abseil-time-subtraction Ensure explicit use of time type
#xabseil-upgrade-duration-conversions Not used, as it suggests possibly unwanted casts, which te compiler already warns us about
#xaltera-id-dependent-backward-branch Not used, cause it did report at every loop # Avoid inperformant design of loops
# altera-kernel-name-restriction Avoid usage of files named similiar to internal API files
# altera-single-work-item-barrier Avoid unnecessary use of barriers
#xaltera-struct-pack-align Not used, cause we don't want allignment messages for structs nnot used in OpenCL kernels
#xaltera-unroll-loops Not used, cause it does not understand expression based unrolls and reports for all code, even code not in kernels
# boost-use-to-string Ensure use of standard library functions where possible
# bugprone-argument-comment Ensure correct use of argument names in comments
# bugprone-assert-side-effect Avoid assertions with side-effects
# bugprone-assignment-in-if-condition Avoid assignments in if-conditions
# bugprone-bad-signal-to-kill-thread Avoid SIGTERM when attempting to kill a thread
# bugprone-bool-pointer-implicit-conversion Avoid implicit conversion from pointer to bool
# bugprone-branch-clone Avoid identical branches
# bugprone-copy-constructor-init Avoid wrong usage of copy constructors
# bugprone-dangling-handle Avoid dangling references
# bugprone-dynamic-static-initializers Avoid dynamic initialization of static variables in possibly shared context
#xbugprone-easily-swappable-parameters Not used, cause it would require refactoring of API
#xbugprone-exception-escape Not used, cause it reported escape were non could take place # Avoid throwing of exceptions where it is not allowed
# bugprone-fold-init-type Ensure explicit use of correct type in fold functions
# bugprone-forward-declaration-namespace Avoid forward declarations in wrong namespace
# bugprone-forwarding-reference-overload Avoid use of perfect forwarding constructor where use of copy or move constructor is suggested
# bugprone-implicit-widening-of-multiplication-result Avoid unintended overflow on multiplication
# bugprone-inaccurate-erase Ensure correct use of erase functions
# bugprone-incorrect-roundings Avoid incorrect rounding of values
# bugprone-infinite-loop Avoid infinite loops
# bugprone-integer-division Avoid integer division in floating-point context
# bugprone-lambda-function-name Avoid printing the name of an unnamed function
# bugprone-macro-parentheses Avoid macros that rely on possibly misleading usage of parenthesis
#xbugprone-macro-repeated-side-effects Not used, cause I don't know what it does
# bugprone-misplaced-operator-in-strlen-in-alloc Avoid probably unintended addition to strings
# bugprone-misplaced-pointer-arithmetic-in-alloc Avoid probably unintended addition to pointers
# bugprone-misplaced-widening-cast Avoid loss of precision by misplaced casts
# bugprone-move-forwarding-reference Ensure forwarding references are forwared not moved
# bugprone-multiple-statement-macro Avoid statements from falling out an conditioned block when inserting macros. (NOTE: Should not happen if ifs without braces are avoided)
# bugprone-no-escape Ensure pointers marked as noescape do not escape from their scope
# bugprone-not-null-terminated-result Avoid strings, that are not null-terminated
# bugprone-parent-virtual-call Avoid calls of inherited virtual functions when a call to non-virtual function is suggested
# bugprone-posix-return Ensure posix fuinctions returning non-negatiove only do not return negative values
# bugprone-redundant-branch-condition Avoid nested if-statements with the same condition a parent has.
# bugprone-reserved-identifier Avoid usage of reserved names
# bugprone-shared-ptr-array-mismatch Avoid wrong initializationj of shared pointers with arrays
# bugprone-signal-handler Ensure correct behaviour of signal handlers
# bugprone-signed-char-misuse Ensure correct conversion from signed char to bigger signed integer types
# bugprone-sizeof-container Avoid use of sizeof where use of .size() is suggested
# bugprone-sizeof-expression Avoid use of sizeof where it is not suggested
# bugprone-spuriously-wake-up-functionsp Avoid missed spurious wakeup
# bugprone-standalone-empty Avoid use of .empty() where use of .clear() is suggested
# bugprone-string-constructor Avoid misuse of string constructors
# bugprone-string-integer-assignment Avoid assignments of integers to strings
# bugprone-string-literal-with-embedded-nul Avoid unintended use of escaped NUL characters in strings
# bugprone-stringview-nullptr Avoid string views of null-pointers
# bugprone-suspicious-enum-usage Avoid misuse of enums as integers where not suggested
# bugprone-suspicious-include Avoid inclusion of implementation files
# bugprone-suspicious-memory-comparison Avoid memory comparison where it seems to be not suggested
# bugprone-suspicious-memset-usage Avoid usage of memset in a way probably not suggested
# bugprone-suspicious-missing-comma Avoid possibly missing commata
# bugprone-suspicious-realloc-usage Ensure that memory does not get lost on failure of realloc
# bugprone-suspicious-semicolon Avoid semicolon where it is probably not intended
# bugprone-suspicious-string-compare Avoid wrong comparison of the result of a string comparison
# bugprone-swapped-arguments Avoid possibly swapped arguments on function calls
# bugprone-terminating-continue Avoid continue from being executed in every loop iteration, skipping parts of the loop body
# bugprone-throw-keyword-missing Ensure throw-keyword is used when exception might be thrown
# bugprone-too-small-loop-variable Ensure loop variables have a type big enough for the loops range
# bugprone-unchecked-optional-access Avoid unsafe access to optionals
# bugprone-undefined-memory-manipulation Avoid undefined manipulation of memory
# bugprone-undelegated-constructor Ensure delegated constructors are correctly called
# bugprone-unhandled-exception-at-new Ensure exception is handled on call of new, if not passed to parent function
#xbugprone-unhandled-self-assignment Not used, cause it reported even if the special case was handled # Avoid data loss on self assignment
# bugprone-unsafe-functions Ensure safe functions are used where available
# bugprone-unused-raii Avoid use of RAII where it is not suggested
# bugprone-unused-return-value Avoid unused return values
# bugprone-use-after-move Avoid usage of an object after it was moved
# bugprone-virtual-near-miss Avoid unintended misname of virtual functions in derived classes
# cert-dcl50-cpp Avoid c-style variadic functions
#xcert-dcl58-cpp Not used, cause use of namespace is probably intended when found
# cert-err34-c Avoid unchecked use of string to integer conversion functions
# cert-err52-cpp Avoid long jumps
# cert-err58-cpp Ensure exceptions in constructors at global space are handled
# cert-err60-cpp Ensure throw expressions are nothrow copy constructible
#xcert-flp30-c Not used, cause floats in for loops are probably intended when encountered
# cert-mem57-cpp Avoid use of default new operator for over-aligned types
#xcert-msc50-cpp Not used, cause usage of random number generators is probably intended when encountered
#xcert-msc51-cpp Not used, cause usage of random number generators is probably intended when encountered
# cert-oop57-cpp Avoid use of memory manipulation functions where a call to an apropriate class function is suggested
# cert-oop58-cpp Ensure source object is not modified on copy constructors
# concurrency-mt-unsafe Avoid parallel calls to non-threadsafe functions
# concurrency-thread-canceltype-asynchronous Ensure pthreads are cancled safely
# cppcoreguidelines-avoid-capture-default-when-capturing-this Avoid misleading captures in lambda functions
# cppcoreguidelines-avoid-capturing-lambda-coroutines Avoid use of already freed variables in asynchronous lambdas
# cppcoreguidelines-avoid-const-or-ref-data-members Ensure const accessors are used instead of const members
#xcppcoreguidelines-avoid-do-while Not used, cause do-while loops can also increase readability in some scenarios
# cppcoreguidelines-avoid-goto Avoid use of goto
# cppcoreguidelines-avoid-non-const-global-variables Avoid global variables, that are not const
# cppcoreguidelines-avoid-reference-coroutine-parameters Avoid dangling references by coroutines
#xcppcoreguidelines-init-variables Not used, cause it marked valid assignments and compiler already does such checks
# cppcoreguidelines-interfaces-global-init Avoid some order-of-initialization problems
# cppcoreguidelines-macro-usage Avoid usage of macros where modern language structures are suggested
# cppcoreguidelines-narrowing-conversions Avoid silent narrwoing
# cppcoreguidelines-no-malloc Avoid usage of c allocation where modern language structures are suggested
#xcppcoreguidelines-owning-memory Not used, cause we don't use gsl
#xcppcoreguidelines-prefer-member-initializer Not used, cause initialization should happen at constructor.
# cppcoreguidelines-pro-bounds-array-to-pointer-decay Avoid usage of pointers as arrays
#xcppcoreguidelines-pro-bounds-constant-array-index Not used, cause it did not detect in fact constant ranges (like for loops with constant upper bound) # Avoid out-of-bounds for static arrays
# cppcoreguidelines-pro-bounds-pointer-arithmetic Avoid usage of pointer-arithmetic
# cppcoreguidelines-pro-type-const-cast Avoid modification of const values
# cppcoreguidelines-pro-type-cstyle-cast Avoid unsafe casts
# cppcoreguidelines-pro-type-member-init Ensure class members are initialized
# cppcoreguidelines-pro-type-reinterpret-cast Avoid unsafe casts
# cppcoreguidelines-pro-type-static-cast-downcast Avoid use of static_cast where dynamic_cast is suggested
# cppcoreguidelines-pro-type-union-access Avoid use of unions (NOTE: Some compilers may explicitly allow the use of unions as type prunning)
# cppcoreguidelines-pro-type-vararg Avoid c-style variadic functions
# cppcoreguidelines-rvalue-reference-param-not-moved Ensure rvalue parameters are moved into a function
# cppcoreguidelines-slicing Avoid copying a derived instance into a base instance
# cppcoreguidelines-special-member-functions Ensure that all special members/constructors are defined
# cppcoreguidelines-virtual-class-destructor Ensure correct definition of virtual destructors
# darwin-avoid-spinlock Avoid use of deprecated locks
# darwin-dispatch-once-nonstatic Avoid undefined behaviour when dispatching
#xfuchsia-default-arguments-calls Not used, cause default arguments are intended to be used
#xfuchsia-default-arguments-declarations Not used, cause default arguments are intended to be used
#xfuchsia-multiple-inheritance Not used, cause multi inheritance is probably intended when encountered
#xfuchsia-overloaded-operator Not used, cause operator overloading is intended to be used
#xfuchsia-statically-constructed-objects Not used, cause already handled by other checks in a less restricting way
#xfuchsia-trailing-return Not used, cause I'm not sure what it does
#xfuchsia-virtual-inheritance Not used, cause virtual inheritance is probably intended when encountered
# google-build-explicit-make-pair Ensure correct types are used in make_pair
# google-build-namespaces Avoid anonymous namespaces in headers
# google-build-using-namespace Ensure explicit use of namespaces
#xgoogle-default-arguments Not used, cause default arguments are intended to be used
# google-explicit-constructor Avoid unintended implicit conversion
# google-global-names-in-headers Avoid excessive use of namespaces in headers
#xgoogle-readability-avoid-underscore-in-googletest-name Not used, cause naming of tests is up to the user
# google-readability-casting Avoid use of c-style casts
#xgoogle-readability-todo Not used, cause TODOs might often be used without assignment to bug numbers or users
#xgoogle-runtime-int Not used, cause platform-specific integer size may be intended
#xgoogle-runtime-operator Not used, cause operator overloading is intended to be used
# google-upgrade-googletest-case Avoid use of deprecated functions
# hicpp-exception-baseclass Ensure only exceptions are thrown
# hicpp-multiway-paths-covered Ensure explicit covering of all branches
# hicpp-no-assembler Avoid inline assembly
#xhicpp-signed-bitwise Not used, cause it is fixed or will be fixed in c++20 # Avoid undefined behaviour at bitwise operations on signed integers
#xllvm-header-guard Not used, cause it does not take care of root directory, generating very weird header guards
#xllvm-include-order Not used, cause different include order style might be wanted by user (see .clang-format)
# llvm-namespace-comment Ensure namespace end comment for long namespaces
#xlvm-prefer-isa-or-dyn-cast-in-conditionals Not used, cause use of different casts might be intended
#xllvm-prefer-register-over-unsigned Not used, cause I don't know where this applies
#xllvm-twine-local Not used, cause I don't know where this applies
#xllvmlibc-callee-namespace Not used, cause I don't know where this applies
#xllvmlibc-implementation-in-namespace Not used, cause I don't know where this applies
#xllvmlibc-inline-function-decl Not used, cause user might not use LLVM for compilation
#xllvmlibc-restrict-system-libc-headers Not used, cause user might not use LLVM for compilation
# misc-confusable-identifiers Avoid confusable identifiers
#xmisc-const-correctness Not used, cause id produced false-positives # Ensure const is used where suggested
# misc-definitions-in-headers Avoid not inlined definitions in headers
# misc-misleading-bidirectional Avoid misleading characters in code
# misc-misleading-identifier Avoid misleading characters in code
# misc-misplaced-const Avoid wrong usage of const caused by typedefs
# misc-new-delete-overloads Ensure each object-level new got an corresponding delete and the other way round
# misc-no-recursion Avoid recursion
# misc-non-copyable-objects Avoid copying types that are not copieable
#xmisc-non-private-member-variables-in-classes Not used, cause this would blow up code massively
# misc-redundant-expression Avoid redundant expressions
# misc-static-assert Avoid use of assert where static_assert is suggested
# misc-throw-by-value-catch-by-reference Ensure exceptions are catched by reference and thrown by value
# misc-unconventional-assign-operator Ensure assignment operators are correctly defined
# misc-uniqueptr-reset-release Ensure unique_ptr are moved on assignment
# misc-unused-alias-decls Avoid unused namespaces aliases
# misc-unused-parameters Avoid unused parameters
# misc-unused-using-decls Avoid unused usings
# misc-use-anonymous-namespace Ensure anonymouse namespaces are preferred before static global scope
# modernize-avoid-bind Avoid binding of functions where lambdas can be used
# modernize-avoid-c-arrays Avoid use of c-style arrays where std::array can be used
#xmodernize-concat-nested-namespaces Not used, as namespaces might be extended, later requiring rewriting
# modernize-deprecated-headers Avoid deprecated headers
# modernize-deprecated-ios-base-aliases Avoid deprecated namespace
#xmodernize-loop-convert Not used, cause range-based for might be bugprone and not usable in some situations
# modernize-macro-to-enum Avoid use of macros, where enums are suggested
#xmodernize-make-shared Not used, cause both does have pros and cons
#xmodernize-make-unique Not used, cause both does have pros and cons
# modernize-pass-by-value Avoid inefficient pass-by-reference
#xmodernize-raw-string-literal Not used, cause raw strings are confusing when mixed with non-raw strings
# modernize-redundant-void-arg Avoid use of void arg
# modernize-replace-auto-ptr Avoid use of deprecated type
# modernize-replace-disallow-copy-and-assign-macro Avoid deprecated macro
# modernize-replace-random-shuffle Avoid use of deprecated function
#xmodernize-return-braced-init-list Not used, cause array initializers hide explicite function calls, making it less clear what happens
# modernize-shrink-to-fit Ensure shrink_to_fit is used where suggested
# modernize-type-traits Ensure type_traits short functions are used
# modernize-unary-static-assert Avoid use of empty string static_assert
#xmodernize-use-auto Not used, cause auto hides type information
# modernize-use-bool-literals Avoid assigning integers to bools
#xmodernize-use-default-member-init Not used, cause initialization should happen at constructor.
# modernize-use-emplace Ensure emplace functions are used where suggested
# modernize-use-equals-default Ensure default constructor is explicitly defined where suggested
# modernize-use-equals-delete Ensure constructor is explicitly deleted where suggested
# modernize-use-nodiscard Ensure nodiscard is used where suggested
# modernize-use-noexcept Ensure noexcept is used where suggested
# modernize-use-nullptr Avoid use of NULL, instead use nullptr
# modernize-use-override Ensure override is used where suggested
#xmodernize-use-trailing-return-type Not used, cause it blows up code
#xmodernize-use-transparent-functors Not used, as the removed type information is probably relevant
# modernize-use-uncaught-exceptions Avoid usage of deprecated type
#xmodernize-use-using Not used, cause typedef has clear syntax and clear use, while using has not
# mpi-buffer-deref Avoid passing double pointers to mpi functions where single pointers are suggested
# mpi-type-mismatch Ensure correct type buffer is passed to mpi function
# openmp-exception-escape Ensure OpenMP blocks are well-bracketed
# openmp-use-default-none Ensure explicit declaration of data sharing type
# performance-faster-string-find Avoid call to find with a string literall where a call with a character is suggested
# performance-for-range-copy Avoid copying values in ranged for loops where use by reference is suggested
# performance-implicit-conversion-in-loop Avoid implicit conversion in ranged for loops
# performance-inefficient-algorithm Avoid inefficient usage of container functiosn where more efficient implementations exist
# performance-inefficient-string-concatenation Avoid addition of strings where appending is suggested
# performance-inefficient-vector-operation Avoid inefficient calls to std::vector functions where it could be acceletarted
# performance-move-const-arg Avoid move where none is suggested
# performance-move-constructor-init Avoid move construictor where copy constructor is suggested in initialization of base classes
# performance-no-automatic-move Avoid const where it prevents moving
# performance-no-int-to-ptr Avoid casts between integer and pointer
# performance-noexcept-move-constructor Ensure move constructors are marked with noexcept
# performance-trivially-destructible Avoid making a function non-trivial destructible when it should be possible
# performance-type-promotion-in-math-fn Ensure math float functions are explicitly called
# performance-unnecessary-copy-initialization Avoid copy initialization where initialization by const reference is suggested
# performance-unnecessary-value-param Avoid pass-by-value where pass-by-reference is suggested
# portability-simd-intrinsics Avoid use of SIMD builtins where standard library (experimental) function is suggested
# portability-std-allocator-const Avoid use of containers of const types
#xreadability-avoid-const-params-in-decls Not used, cause it may be intended to match declaration and definition
# readability-avoid-unconditional-preprocessor-if Avoid preprocessor ifs always evaluation to zrue/false
# readability-braces-around-statements Avoid conditionals and loops without braces, as they are bad readable, bugprone and bat maintainable
# readability-const-return-type Avoid const in return types, improving compiler optimizations
# readability-container-contains Avoid usage of find() and count() where use of contains() is suggested
# readability-container-data-pointer Ensure data() is used where available
# readability-container-size-empty Avoid usage of size() where use of empty() is suggested
# readability-convert-member-functions-to-static Ensure members are declared static when they actually are static
# readability-delete-null-pointer Avoid checks for nullptr where it is unnecessary
# readability-duplicate-include Avoid duplicate includes
#xreadability-else-after-return Not used, cause explicit usage of branches might highlight branch covering
#xreadability-function-cognitive-complexity Not used, cause no easy fis is suggested
#xreadability-function-size Not used, cause no easy fis is suggested
#xreadability-identifier-length Not used, cause no easy fis is suggested
# readability-identifier-naming Ensure consistent naming of identifiers
# readability-implicit-bool-conversion Avoid implicit conversion of bool
# readability-inconsistent-declaration-parameter-name Ensure names of parameters in definition match name of parametersin declaration
# readability-isolate-declaration Avoid declaring several variables in one statement
# readability-magic-numbers Avoid magic numbers
#xreadability-make-member-function-const Not used, cause is produces wrong results (mark functions const that have non-const access to members) # Ensure constant member functions are declared const
# readability-misleading-indentatione Ensure intendation is consistent
# readability-misplaced-array-index Avoid misused array index
# readability-named-parameter Ensure parameters are named
#xreadability-non-const-parameter Not used, cause is produces wrong results (mark parameters const that are have non-const accessed) # Ensure the use constant pointers where suggested
# readability-operators-representation Avoid mixed tokens for operators
# readability-qualified-auto Ensure auto pointers are declared as pointers
# readability-redundant-access-specifiers Avoid dooubling of access specifiers
# readability-redundant-control-flow Avoid unnecessary return or continue
# readability-redundant-declaration Avoid redundant declarations
# readability-redundant-function-ptr-dereference Avoid doubled dereferencing of functions where single dereference is suggested
# readability-redundant-member-init Avoid unnecessary member initialization
# readability-redundant-preprocessor Avoid redundant preprocessors
# readability-redundant-smartptr-get Avoid doubled dereferencing of smart pointers where single dereference is suggested
# readability-redundant-string-cstr Avoid calls to c_str where it is not necessary
# readability-redundant-string-init Avoid unnecessary string initialization
# readability-simplify-boolean-expr Avoid complex boolean expressions when simple ones are suggested
# readability-simplify-subscript-expr Avoid call to data() where it is not necessary
# readability-static-accessed-through-instance Avoid access of static members through instances
# readability-static-definition-in-anonymous-namespace Avoid unnecessary static in anonymous namespace
# readability-string-compare Ensure string compare function is used where suggested
#xreadability-suspicious-call-argument Not used as too heuristic
# readability-uniqueptr-delete-release Avoid complex deletion of unique pointers
#xreadability-uppercase-literal-suffix Not used, cause lower case is completely valid
# readability-use-anyofallof Avoid use of ranged for loop where special function is suggested
Checks: >
abseil-cleanup-ctad
,abseil-duration-addition
,abseil-duration-comparison
,abseil-duration-conversion-cast
,abseil-duration-division
,abseil-duration-factory-float
,abseil-duration-factory-scale
,abseil-duration-subtraction
,abseil-duration-unnecessary-conversion
,abseil-faster-strsplit-delimiter
,abseil-redundant-strcat-calls
,abseil-str-cat-append
,abseil-string-find-startswith
,abseil-time-comparison
,abseil-time-subtraction
,altera-kernel-name-restriction
,altera-single-work-item-barrier
,boost-use-to-string
,bugprone-argument-comment
,bugprone-assert-side-effect
,bugprone-assignment-in-if-condition
,bugprone-bad-signal-to-kill-thread
,bugprone-bool-pointer-implicit-conversion
,bugprone-branch-clone
,bugprone-copy-constructor-init
,bugprone-dangling-handle
,bugprone-dynamic-static-initializers
,bugprone-fold-init-type
,bugprone-forward-declaration-namespace
,bugprone-forwarding-reference-overload
,bugprone-implicit-widening-of-multiplication-result
,bugprone-inaccurate-erase
,bugprone-incorrect-roundings
,bugprone-infinite-loop
,bugprone-integer-division
,bugprone-lambda-function-name
,bugprone-macro-parentheses
,bugprone-misplaced-operator-in-strlen-in-alloc
,bugprone-misplaced-pointer-arithmetic-in-alloc
,bugprone-misplaced-widening-cast
,bugprone-move-forwarding-reference
,bugprone-multiple-statement-macro
,bugprone-no-escape
,bugprone-not-null-terminated-result
,bugprone-parent-virtual-call
,bugprone-posix-return
,bugprone-redundant-branch-condition
,bugprone-reserved-identifier
,bugprone-shared-ptr-array-mismatch
,bugprone-signal-handler
,bugprone-signed-char-misuse
,bugprone-sizeof-container
,bugprone-sizeof-expression
,bugprone-spuriously-wake-up-functions
,bugprone-standalone-empty
,bugprone-string-constructor
,bugprone-string-integer-assignment
,bugprone-string-literal-with-embedded-nul
,bugprone-stringview-nullptr
,bugprone-suspicious-enum-usage
,bugprone-suspicious-include
,bugprone-suspicious-memory-comparison
,bugprone-suspicious-memset-usage
,bugprone-suspicious-missing-comma
,bugprone-suspicious-realloc-usage
,bugprone-suspicious-semicolon
,bugprone-suspicious-string-compare
,bugprone-swapped-arguments
,bugprone-terminating-continue
,bugprone-throw-keyword-missing
,bugprone-too-small-loop-variable
,bugprone-unchecked-optional-access
,bugprone-undefined-memory-manipulation
,bugprone-undelegated-constructor
,bugprone-unhandled-exception-at-new
,bugprone-unsafe-functions
,bugprone-unused-raii
,bugprone-unused-return-value
,bugprone-use-after-move
,bugprone-virtual-near-miss
,cert-dcl50-cpp
,cert-err34-c
,cert-err52-cpp
,cert-err58-cpp
,cert-err60-cpp
,cert-mem57-cpp
,cert-oop57-cpp
,cert-oop58-cpp
,concurrency-mt-unsafe
,concurrency-thread-canceltype-asynchronous
,cppcoreguidelines-avoid-capture-default-when-capturing-this
,cppcoreguidelines-avoid-capturing-lambda-coroutines
,cppcoreguidelines-avoid-const-or-ref-data-members
,cppcoreguidelines-avoid-goto
,cppcoreguidelines-avoid-non-const-global-variables
,cppcoreguidelines-avoid-reference-coroutine-parameters
,cppcoreguidelines-interfaces-global-init
,cppcoreguidelines-macro-usage
,cppcoreguidelines-narrowing-conversions
,cppcoreguidelines-no-malloc
,cppcoreguidelines-pro-bounds-array-to-pointer-decay
,cppcoreguidelines-pro-bounds-pointer-arithmetic
,cppcoreguidelines-pro-type-const-cast
,cppcoreguidelines-pro-type-cstyle-cast
,cppcoreguidelines-pro-type-member-init
,cppcoreguidelines-pro-type-reinterpret-cast
,cppcoreguidelines-pro-type-static-cast-downcast
,cppcoreguidelines-pro-type-union-access
,cppcoreguidelines-pro-type-vararg
,cppcoreguidelines-rvalue-reference-param-not-moved
,cppcoreguidelines-slicing
,cppcoreguidelines-special-member-functions
,cppcoreguidelines-virtual-class-destructor
,darwin-avoid-spinlock
,darwin-dispatch-once-nonstatic
,google-build-explicit-make-pair
,google-build-namespaces
,google-build-using-namespace
,google-explicit-constructor
,google-global-names-in-headers
,google-readability-casting
,google-upgrade-googletest-case
,hicpp-exception-baseclass
,hicpp-multiway-paths-covered
,hicpp-no-assembler
,llvm-namespace-comment
,misc-confusable-identifiers
,misc-definitions-in-headers
,misc-misleading-bidirectional
,misc-misleading-identifier
,misc-misplaced-const
,misc-new-delete-overloads
,misc-no-recursion
,misc-non-copyable-objects
,misc-redundant-expression
,misc-static-assert
,misc-throw-by-value-catch-by-reference
,misc-unconventional-assign-operator
,misc-uniqueptr-reset-release
,misc-unused-alias-decls
,misc-unused-parameters
,misc-unused-using-decls
,misc-use-anonymous-namespace
,modernize-avoid-bind
,modernize-avoid-c-arrays
,modernize-deprecated-headers
,modernize-deprecated-ios-base-aliases
,modernize-macro-to-enum
,modernize-pass-by-value
,modernize-redundant-void-arg
,modernize-replace-auto-ptr
,modernize-replace-disallow-copy-and-assign-macro
,modernize-replace-random-shuffle
,modernize-shrink-to-fit
,modernize-type-traits
,modernize-unary-static-assert
,modernize-use-bool-literals
,modernize-use-emplace
,modernize-use-equals-default
,modernize-use-equals-delete
,modernize-use-nodiscard
,modernize-use-noexcept
,modernize-use-nullptr
,modernize-use-override
,modernize-use-uncaught-exceptions
,mpi-buffer-deref
,mpi-type-mismatch
,openmp-exception-escape
,openmp-use-default-none
,performance-faster-string-find
,performance-for-range-copy
,performance-implicit-conversion-in-loop
,performance-inefficient-algorithm
,performance-inefficient-string-concatenation
,performance-inefficient-vector-operation
,performance-move-const-arg
,performance-move-constructor-init
,performance-no-automatic-move
,performance-no-int-to-ptr
,performance-noexcept-move-constructor
,performance-trivially-destructible
,performance-type-promotion-in-math-fn
,performance-unnecessary-copy-initialization
,performance-unnecessary-value-param
,portability-simd-intrinsics
,portability-std-allocator-const
,readability-avoid-unconditional-preprocessor-if
,readability-braces-around-statements
,readability-const-return-type
,readability-container-contains
,readability-container-data-pointer
,readability-container-size-empty
,readability-convert-member-functions-to-static
,readability-delete-null-pointer
,readability-duplicate-include
,readability-identifier-naming
,readability-implicit-bool-conversion
,readability-inconsistent-declaration-parameter-name
,readability-isolate-declaration
,readability-magic-numbers
,readability-misleading-indentation
,readability-misplaced-array-index
,readability-named-parameter
,readability-operators-representation
,readability-qualified-auto
,readability-redundant-access-specifiers
,readability-redundant-control-flow
,readability-redundant-declaration
,readability-redundant-function-ptr-dereference
,readability-redundant-member-init
,readability-redundant-preprocessor
,readability-redundant-smartptr-get
,readability-redundant-string-cstr
,readability-redundant-string-init
,readability-simplify-boolean-expr
,readability-simplify-subscript-expr
,readability-static-accessed-through-instance
,readability-static-definition-in-anonymous-namespace
,readability-string-compare
,readability-uniqueptr-delete-release
,readability-use-anyofallof
CheckOptions:
- key: bugprone-argument-comment.StrictMode # Must be the exact parameter name
value: true
- key: bugprone-misplaced-widening-cast.CheckImplicitCasts # Also check implicit casts
value: true
- key: bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression # Warn when fetching sizeof integer value
value: true
- key: bugprone-string-constructor.WarnOnLargeLength # Large strings are probably intended when encountered
value: true
- key: bugprone-suspicious-enum-usage.StrictMode # Also detect suspicious enums
value: true
- key: bugprone-suspicious-missing-comma.SizeThreshold # Detect all occurencies
value: 0
- key: bugprone-suspicious-missing-comma.RatioThreshold # Detect all occurencies
value: 1.0
- key: bugprone-suspicious-missing-comma.MaxConcatenatedTokens # But not if we got more than x tokens
value: 5
- key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison # Also warn on negation
value: true
- key: bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField # Always warn
value: false
- key: cppcoreguidelines-narrowing-conversions.WarnWithinTemplateInstantiation # Also warn on template instantiations
value: true
- key: cppcoreguidelines-narrowing-conversions.PedanticMode # Also warn when assigned value is exactly representable
value: true
- key: cppcoreguidelines-pro-type-member-init.IgnoreArrays # Ignore arrays for performance reason
value: true
- key: cppcoreguidelines-pro-type-member-init.UseAssignment # Use assignment, cause bracket initializer hides information about the called function
value: true
- key: hicpp-multiway-paths-covered.WarnOnMissingElse # Also warn if else branch is not covered
value: true
- key: misc-const-correctness.WarnPointersAsValues # Also warn for pointer values
value: true
- key: misc-const-correctness.TransformPointersAsValues # Also transform for pointer values
value: true
- key: modernize-avoid-bind.PermissiveParameterList # Avoid errors causd by replacement
value: true
- key: performance-for-range-copy.WarnOnAllAutoCopies # Warn when using auto in ranged for loops
value: true
- key: performance-inefficient-string-concatenation.StrictMode # Check everywhere
value: true
- key: portability-simd-intrinsics.Suggest # Suggest alternatives
value: true
- key: readability-identifier-naming.GetConfigPerFile # Use config from where the identifier is defined
value: true
- key: readability-inconsistent-declaration-parameter-name.Strict # Parameters must match exactly
value: true
- key: readability-magic-numbers.IgnoredIntegerValues # Only accept 0 and 1 (for bitwise operation and as true value=
value: '1'
- key: readability-magic-numbers.IgnoredFloatingPointValues # Only accept 0.0 and 1.0 (for 1.0/x)
value: '1.0'
- key: readability-magic-numbers.IgnoreTypeAliases # Ignore in type definitions
value: true
- key: readability-magic-numbers.IgnoreUserDefinedLiterals # Ignore in literal definitions
value: true
- key: readability-redundant-member-init.IgnoreBaseInCopyConstructors # Ignore unnecessary base class initialuization for compiler compatibility
value: true
- key: readability-uniqueptr-delete-release.PreferResetCall # Call reset instead of assigning nullptr
value: true
#Naming conventions
- key: readability-identifier-naming.AbstractClassCase
value: CamelCase
- key: readability-identifier-naming.ClassCase
value: CamelCase
- key: readability-identifier-naming.ClassConstantCase
value: UPPER_CASE
- key: readability-identifier-naming.ClassMemberCase
value: lower_case
- key: readability-identifier-naming.ClassMethodCase
value: lower_case
- key: readability-identifier-naming.ConstantCase
value: lower_case
- key: readability-identifier-naming.ConstantMemberCase
value: lower_case
- key: readability-identifier-naming.ConstantParameterCase
value: lower_case
- key: readability-identifier-naming.ConstantPointerParameterCase
value: lower_case
- key: readability-identifier-naming.ConstexprMethodCase
value: lower_case
- key: readability-identifier-naming.ConstexprVariableCase
value: UPPER_CASE
- key: readability-identifier-naming.EnumCase
value: CamelCase
- key: readability-identifier-naming.EnumConstantCase
value: CamelCase
- key: readability-identifier-naming.FunctionCase
value: lower_case
- key: readability-identifier-naming.GlobalConstantCase
value: UPPER_CASE
- key: readability-identifier-naming.GlobalConstantPointerCase
value: UPPER_CASE
- key: readability-identifier-naming.GlobalFunctionCase
value: lower_case
- key: readability-identifier-naming.GlobalPointerCase
value: lower_case
- key: readability-identifier-naming.GlobalVariableCase
value: lower_case
- key: readability-identifier-naming.InlineNamespaceCase
value: lower_case
- key: readability-identifier-naming.LocalConstantCase
value: lower_case
- key: readability-identifier-naming.LocalConstantPointerCase
value: lower_case
- key: readability-identifier-naming.LocalPointerCase
value: lower_case
- key: readability-identifier-naming.LocalVariableCase
value: lower_case
- key: readability-identifier-naming.MacroDefinitionCase
value: UPPER_CASE
- key: readability-identifier-naming.MemberCase
value: lower_case
- key: readability-identifier-naming.MethodCase
value: lower_case
- key: readability-identifier-naming.NamespaceCase
value: lower_case
- key: readability-identifier-naming.ParameterCase
value: lower_case
- key: readability-identifier-naming.ParameterPackCase
value: lower_case
- key: readability-identifier-naming.PointerParameterCase
value: lower_case
- key: readability-identifier-naming.PrivateMemberCase
value: lower_case
- key: readability-identifier-naming.PrivateMethodCase
value: lower_case
- key: readability-identifier-naming.ProtectedMemberCase
value: lower_case
- key: readability-identifier-naming.ProtectedMethodCase
value: lower_case
- key: readability-identifier-naming.PublicMemberCase
value: lower_case
- key: readability-identifier-naming.PublicMethodCase
value: lower_case
- key: readability-identifier-naming.ScopedEnumConstantCase
value: UPPER_CASE
- key: readability-identifier-naming.StaticConstantCase
value: UPPER_CASE
- key: readability-identifier-naming.StaticVariableCase
value: lower_case
- key: readability-identifier-naming.StructCase
value: CamelCase
- key: readability-identifier-naming.TemplateParameterCase
value: CamelCase
- key: readability-identifier-naming.TemplateTemplateParameterCase
value: CamelCase
- key: readability-identifier-naming.TypeTemplateParameterCase
value: CamelCase
- key: readability-identifier-naming.UnionCase
value: CamelCase
- key: readability-identifier-naming.ValueTemplateParameterCase
value: CamelCase
- key: readability-identifier-naming.VariableCase
value: lower_case
- key: readability-identifier-naming.VirtualMethodCase
value: CamelCase
FormatStyle: file # Use .clang-format for formatting
HeaderFileExtensions: ['h', 'hh', 'hpp', 'hxx', 'cuh'] # All headers, including CUDA headers
ImplementationFileExtensions: ['c', 'cc', 'cpp', 'cxx', 'cu'] # All implementations, including CUDA implementations
InheritParentConfig: true # Inherit parent config if available
#SystemHeaders: false # Ignore system headers
UseColor: true # Use colors if available
WarningsAsErrors: true # Treat all warnings as errors
================================================
FILE: .gitignore
================================================
.vscode
build
clang-format-all.bat
clang-tidy-all.bat
fix_compilation_database.py
**/*.so
**/*.exe.manifest
**/*.exe
**/*.bgeo
================================================
FILE: .gitmodules
================================================
[submodule "Data"]
path = Data
url = https://github.com/littlemine/Data.git
================================================
FILE: CMake/DownloadProject.CMakeLists.cmake.in
================================================
cmake_minimum_required(VERSION 2.8.2)
project(${DL_ARGS_PROJ}-download NONE)
include(ExternalProject)
ExternalProject_Add(${DL_ARGS_PROJ}-download
${DL_ARGS_UNPARSED_ARGUMENTS}
SOURCE_DIR "${DL_ARGS_SOURCE_DIR}"
BINARY_DIR "${DL_ARGS_BINARY_DIR}"
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
TEST_COMMAND ""
)
================================================
FILE: CMake/DownloadProject.LICENSE
================================================
The MIT License (MIT)
Copyright (c) 2015 Crascit
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: CMake/DownloadProject.cmake
================================================
# MODULE: DownloadProject
#
# PROVIDES:
# download_project( PROJ projectName
# [PREFIX prefixDir]
# [DOWNLOAD_DIR downloadDir]
# [SOURCE_DIR srcDir]
# [BINARY_DIR binDir]
# [QUIET]
# ...
# )
#
# Provides the ability to download and unpack a tarball, zip file, git repository,
# etc. at configure time (i.e. when the cmake command is run). How the downloaded
# and unpacked contents are used is up to the caller, but the motivating case is
# to download source code which can then be included directly in the build with
# add_subdirectory() after the call to download_project(). Source and build
# directories are set up with this in mind.
#
# The PROJ argument is required. The projectName value will be used to construct
# the following variables upon exit (obviously replace projectName with its actual
# value):
#
# projectName_SOURCE_DIR
# projectName_BINARY_DIR
#
# The SOURCE_DIR and BINARY_DIR arguments are optional and would not typically
# need to be provided. They can be specified if you want the downloaded source
# and build directories to be located in a specific place. The contents of
# projectName_SOURCE_DIR and projectName_BINARY_DIR will be populated with the
# locations used whether you provide SOURCE_DIR/BINARY_DIR or not.
#
# The DOWNLOAD_DIR argument does not normally need to be set. It controls the
# location of the temporary CMake build used to perform the download.
#
# The PREFIX argument can be provided to change the base location of the default
# values of DOWNLOAD_DIR, SOURCE_DIR and BINARY_DIR. If all of those three arguments
# are provided, then PREFIX will have no effect. The default value for PREFIX is
# CMAKE_BINARY_DIR.
#
# The QUIET option can be given if you do not want to show the output associated
# with downloading the specified project.
#
# In addition to the above, any other options are passed through unmodified to
# ExternalProject_Add() to perform the actual download, patch and update steps.
# The following ExternalProject_Add() options are explicitly prohibited (they
# are reserved for use by the download_project() command):
#
# CONFIGURE_COMMAND
# BUILD_COMMAND
# INSTALL_COMMAND
# TEST_COMMAND
#
# Only those ExternalProject_Add() arguments which relate to downloading, patching
# and updating of the project sources are intended to be used. Also note that at
# least one set of download-related arguments are required.
#
# If using CMake 3.2 or later, the UPDATE_DISCONNECTED option can be used to
# prevent a check at the remote end for changes every time CMake is run
# after the first successful download. See the documentation of the ExternalProject
# module for more information. It is likely you will want to use this option if it
# is available to you.
#
# EXAMPLE USAGE:
#
# include(download_project.cmake)
# download_project(PROJ googletest
# GIT_REPOSITORY https://github.com/google/googletest.git
# GIT_TAG master
# UPDATE_DISCONNECTED 1
# QUIET
# )
#
# add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
#
#========================================================================================
set(_DownloadProjectDir "${CMAKE_CURRENT_LIST_DIR}")
include(CMakeParseArguments)
function(download_project)
set(options QUIET)
set(oneValueArgs
PROJ
PREFIX
DOWNLOAD_DIR
SOURCE_DIR
BINARY_DIR
# Prevent the following from being passed through
CONFIGURE_COMMAND
BUILD_COMMAND
INSTALL_COMMAND
TEST_COMMAND
)
set(multiValueArgs "")
cmake_parse_arguments(DL_ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
# Hide output if requested
if (DL_ARGS_QUIET)
set(OUTPUT_QUIET "OUTPUT_QUIET")
else()
unset(OUTPUT_QUIET)
message(STATUS "Downloading/updating ${DL_ARGS_PROJ}")
endif()
# Set up where we will put our temporary CMakeLists.txt file and also
# the base point below which the default source and binary dirs will be
if (NOT DL_ARGS_PREFIX)
set(DL_ARGS_PREFIX "${CMAKE_BINARY_DIR}")
endif()
if (NOT DL_ARGS_DOWNLOAD_DIR)
set(DL_ARGS_DOWNLOAD_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-download")
endif()
# Ensure the caller can know where to find the source and build directories
if (NOT DL_ARGS_SOURCE_DIR)
set(DL_ARGS_SOURCE_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-src")
endif()
if (NOT DL_ARGS_BINARY_DIR)
set(DL_ARGS_BINARY_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-build")
endif()
set(${DL_ARGS_PROJ}_SOURCE_DIR "${DL_ARGS_SOURCE_DIR}" PARENT_SCOPE)
set(${DL_ARGS_PROJ}_BINARY_DIR "${DL_ARGS_BINARY_DIR}" PARENT_SCOPE)
# Create and build a separate CMake project to carry out the download.
# If we've already previously done these steps, they will not cause
# anything to be updated, so extra rebuilds of the project won't occur.
configure_file("${_DownloadProjectDir}/DownloadProject.CMakeLists.cmake.in"
"${DL_ARGS_DOWNLOAD_DIR}/CMakeLists.txt")
execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
${OUTPUT_QUIET}
WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}"
)
execute_process(COMMAND ${CMAKE_COMMAND} --build .
${OUTPUT_QUIET}
WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}"
)
endfunction()
================================================
FILE: CMake/FindWayland.cmake
================================================
# Try to find Wayland on a Unix system
#
# This will define:
#
# WAYLAND_FOUND - True if Wayland is found
# WAYLAND_LIBRARIES - Link these to use Wayland
# WAYLAND_INCLUDE_DIR - Include directory for Wayland
# WAYLAND_DEFINITIONS - Compiler flags for using Wayland
#
# In addition the following more fine grained variables will be defined:
#
# WAYLAND_CLIENT_FOUND WAYLAND_CLIENT_INCLUDE_DIR WAYLAND_CLIENT_LIBRARIES
# WAYLAND_SERVER_FOUND WAYLAND_SERVER_INCLUDE_DIR WAYLAND_SERVER_LIBRARIES
# WAYLAND_EGL_FOUND WAYLAND_EGL_INCLUDE_DIR WAYLAND_EGL_LIBRARIES
#
# Copyright (c) 2013 Martin Gräßlin <mgraesslin@kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
IF (NOT WIN32)
IF (WAYLAND_INCLUDE_DIR AND WAYLAND_LIBRARIES)
# In the cache already
SET(WAYLAND_FIND_QUIETLY TRUE)
ENDIF ()
# Use pkg-config to get the directories and then use these values
# in the FIND_PATH() and FIND_LIBRARY() calls
FIND_PACKAGE(PkgConfig)
PKG_CHECK_MODULES(PKG_WAYLAND QUIET wayland-client wayland-server wayland-egl wayland-cursor)
SET(WAYLAND_DEFINITIONS ${PKG_WAYLAND_CFLAGS})
FIND_PATH(WAYLAND_CLIENT_INCLUDE_DIR NAMES wayland-client.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
FIND_PATH(WAYLAND_SERVER_INCLUDE_DIR NAMES wayland-server.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
FIND_PATH(WAYLAND_EGL_INCLUDE_DIR NAMES wayland-egl.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
FIND_PATH(WAYLAND_CURSOR_INCLUDE_DIR NAMES wayland-cursor.h HINTS ${PKG_WAYLAND_INCLUDE_DIRS})
FIND_LIBRARY(WAYLAND_CLIENT_LIBRARIES NAMES wayland-client HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
FIND_LIBRARY(WAYLAND_SERVER_LIBRARIES NAMES wayland-server HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
FIND_LIBRARY(WAYLAND_EGL_LIBRARIES NAMES wayland-egl HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
FIND_LIBRARY(WAYLAND_CURSOR_LIBRARIES NAMES wayland-cursor HINTS ${PKG_WAYLAND_LIBRARY_DIRS})
set(WAYLAND_INCLUDE_DIR ${WAYLAND_CLIENT_INCLUDE_DIR} ${WAYLAND_SERVER_INCLUDE_DIR} ${WAYLAND_EGL_INCLUDE_DIR} ${WAYLAND_CURSOR_INCLUDE_DIR})
set(WAYLAND_LIBRARIES ${WAYLAND_CLIENT_LIBRARIES} ${WAYLAND_SERVER_LIBRARIES} ${WAYLAND_EGL_LIBRARIES} ${WAYLAND_CURSOR_LIBRARIES})
list(REMOVE_DUPLICATES WAYLAND_INCLUDE_DIR)
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_CLIENT DEFAULT_MSG WAYLAND_CLIENT_LIBRARIES WAYLAND_CLIENT_INCLUDE_DIR)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_SERVER DEFAULT_MSG WAYLAND_SERVER_LIBRARIES WAYLAND_SERVER_INCLUDE_DIR)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_EGL DEFAULT_MSG WAYLAND_EGL_LIBRARIES WAYLAND_EGL_INCLUDE_DIR)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND_CURSOR DEFAULT_MSG WAYLAND_CURSOR_LIBRARIES WAYLAND_CURSOR_INCLUDE_DIR)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(WAYLAND DEFAULT_MSG WAYLAND_LIBRARIES WAYLAND_INCLUDE_DIR)
MARK_AS_ADVANCED(
WAYLAND_INCLUDE_DIR WAYLAND_LIBRARIES
WAYLAND_CLIENT_INCLUDE_DIR WAYLAND_CLIENT_LIBRARIES
WAYLAND_SERVER_INCLUDE_DIR WAYLAND_SERVER_LIBRARIES
WAYLAND_EGL_INCLUDE_DIR WAYLAND_EGL_LIBRARIES
WAYLAND_CURSOR_INCLUDE_DIR WAYLAND_CURSOR_LIBRARIES
)
ENDIF ()
================================================
FILE: CMake/FindXCB.cmake
================================================
# - FindXCB
#
# Copyright 2015 Valve Coporation
find_package(PkgConfig)
if(NOT XCB_FIND_COMPONENTS)
set(XCB_FIND_COMPONENTS xcb)
endif()
include(FindPackageHandleStandardArgs)
set(XCB_FOUND true)
set(XCB_INCLUDE_DIRS "")
set(XCB_LIBRARIES "")
foreach(comp ${XCB_FIND_COMPONENTS})
# component name
string(TOUPPER ${comp} compname)
string(REPLACE "-" "_" compname ${compname})
# header name
string(REPLACE "xcb-" "" headername xcb/${comp}.h)
# library name
set(libname ${comp})
pkg_check_modules(PC_${comp} QUIET ${comp})
find_path(${compname}_INCLUDE_DIR NAMES ${headername}
HINTS
${PC_${comp}_INCLUDEDIR}
${PC_${comp}_INCLUDE_DIRS}
)
find_library(${compname}_LIBRARY NAMES ${libname}
HINTS
${PC_${comp}_LIBDIR}
${PC_${comp}_LIBRARY_DIRS}
)
find_package_handle_standard_args(${comp}
FOUND_VAR ${comp}_FOUND
REQUIRED_VARS ${compname}_INCLUDE_DIR ${compname}_LIBRARY)
mark_as_advanced(${compname}_INCLUDE_DIR ${compname}_LIBRARY)
list(APPEND XCB_INCLUDE_DIRS ${${compname}_INCLUDE_DIR})
list(APPEND XCB_LIBRARIES ${${compname}_LIBRARY})
if(NOT ${comp}_FOUND)
set(XCB_FOUND false)
endif()
endforeach()
list(REMOVE_DUPLICATES XCB_INCLUDE_DIRS)
================================================
FILE: CMake-Utils/setup_cpp.cmake
================================================
function(add_cpp_executable binary)
add_executable(${binary} ${ARGN})
target_compile_options(${binary}
INTERFACE "${CMAKE_CXX_FLAGS} -O3 -fPIE -fuse-ld=lld -fvisibility=hidden"
) # -flto=thin -fsanitize=cfi
# -fsanitize=address memory thread
set_target_properties(${binary}
PROPERTIES CXX_STANDARD 20
LINKER_LANGUAGE CXX
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
target_compile_features(${binary}
INTERFACE cxx_std_20
)
target_link_libraries(${binary}
PUBLIC #pthread
#stdc++
fmt
)
message("-- [${binary}]\tcpp executable build config")
endfunction(add_cpp_executable)
function(add_cpp_executable_debug binary)
add_executable(${binary} ${ARGN})
target_compile_options(${binary}
INTERFACE "${CMAKE_CXX_FLAGS} -O2 -fPIE -fuse-ld=lld -fvisibility=hidden -fsanitize=address -fsanitize=memory -fsanitize=thread -fno-sanitize-trap=cfi"
) # -flto=thin -fsanitize=cfi
# -fsanitize=address memory thread
set_target_properties(${binary}
PROPERTIES CXX_STANDARD 20
LINKER_LANGUAGE CXX
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
target_compile_features(${binary}
INTERFACE cxx_std_20
)
target_link_libraries(${binary}
PUBLIC #pthread
#stdc++
fmt
)
message("-- [${binary}]\tcpp debug executable build config")
endfunction(add_cpp_executable_debug)
================================================
FILE: CMake-Utils/setup_cuda.cmake
================================================
message("## setup cuda")
#Find CUDA
include(CheckLanguage)
check_language(CUDA)
if(CMAKE_CUDA_COMPILER)
enable_language(CUDA)
message("-- cuda-compiler " ${CMAKE_CUDA_COMPILER})
else()
message(STATUS "No CUDA support")
endif()
set(CUDA_FOUND ${CMAKE_CUDA_COMPILER})
#Set Architecture
set(CMAKE_CUDA_ARCHITECTURES native)
# reference: https://cliutils.gitlab.io/modern-cmake/chapters/packages/CUDA.html
function(CUDA_CONVERT_FLAGS EXISTING_TARGET)
get_property(old_flags
TARGET ${EXISTING_TARGET}
PROPERTY INTERFACE_COMPILE_OPTIONS
)
if(NOT "${old_flags}" STREQUAL "")
string(REPLACE ";" "," CUDA_flags "${old_flags}")
set_property(
TARGET ${EXISTING_TARGET}
PROPERTY INTERFACE_COMPILE_OPTIONS
"$<$<BUILD_INTERFACE:$<COMPILE_LANGUAGE:CXX>>:${old_flags}>$<$<BUILD_INTERFACE:$<COMPILE_LANGUAGE:CUDA>>:-Xcompiler=${CUDA_flags}>"
)
endif()
endfunction()
#Cmake does not handle linking correctly for separable compilation: https://gitlab.kitware.com/cmake/cmake/-/issues/22788
function(GET_DEVICE_LINK_PATH TARGET_NAME ret)
cmake_path(SET DEVICE_LINK_PATH ${CMAKE_BINARY_DIR})
cmake_path(APPEND DEVICE_LINK_PATH "CMakeFiles")
cmake_path(APPEND DEVICE_LINK_PATH ${TARGET_NAME}.dir)
cmake_path(APPEND DEVICE_LINK_PATH ${CMAKE_BUILD_TYPE})
cmake_path(APPEND DEVICE_LINK_PATH "cmake_device_link.obj")
set(${ret} ${DEVICE_LINK_PATH} PARENT_SCOPE)
endfunction()
function(add_cuda_executable binary)
if(CUDA_FOUND)
add_executable(${binary} ${ARGN})
# seems not working
target_compile_options(${binary}
PRIVATE $<$<AND:$<CONFIG:Debug>,$<COMPILE_LANGUAGE:CUDA>>:-g> --expt-extended-lambda --expt-relaxed-constexpr --default-stream=per-thread --use_fast_math -lineinfo --ptxas-options=-allow-expensive-optimizations=true>
)
target_compile_features(${binary}
PRIVATE cuda_std_17
)
set_target_properties(${binary}
PROPERTIES CUDA_EXTENSIONS ON
CUDA_SEPARABLE_COMPILATION OFF
#LINKER_LANGUAGE CUDA
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
GET_DEVICE_LINK_PATH(${binary} DEVICE_LINK_PATH)
target_link_libraries(${binary}
PRIVATE mncuda
)
target_link_options(${binary}
PRIVATE /NODEFAULTLIB:libcmt.lib
)
install(TARGETS
${binary}
)
message("-- [${binary}]\tcuda executable build config")
endif()
endfunction(add_cuda_executable)
function(add_cuda_library library)
if(CUDA_FOUND)
add_library(${library} ${ARGN})
# seems not working
target_compile_options(${library}
PUBLIC $<$<AND:$<CONFIG:Debug>,$<COMPILE_LANGUAGE:CUDA>>:-g> --expt-extended-lambda --expt-relaxed-constexpr --default-stream=per-thread --use_fast_math -lineinfo --ptxas-options=-allow-expensive-optimizations=true>
)
#target_link_options(${library}
# PRIVATE $<$<LINKER_LANGUAGE:CUDA>:-arch=sm_75>
#)
target_compile_features(${library}
PRIVATE cuda_std_17
)
set_target_properties(${library}
PROPERTIES CUDA_EXTENSIONS ON
CUDA_SEPARABLE_COMPILATION OFF
CUDA_RESOLVE_DEVICE_SYMBOLS OFF
POSITION_INDEPENDENT_CODE ON
#LINKER_LANGUAGE CUDA
)
target_compile_definitions(${library}
PUBLIC CMAKE_GENERATOR_PLATFORM=x64
)
message("-- [${library}]\tcuda executable build config")
endif()
endfunction(add_cuda_library)
================================================
FILE: CMake-Utils/setup_externallibs.cmake
================================================
#####
set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM.cmake")
set(CPM_DOWNLOAD_VERSION 0.38.1)
if(NOT (EXISTS ${CPM_DOWNLOAD_LOCATION} AND CPM_VERSION STREQUAL CPM_DOWNLOAD_VERSION))
message(STATUS "Downloading CPM.cmake")
file(DOWNLOAD https://github.com/TheLartians/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake ${CPM_DOWNLOAD_LOCATION})
endif()
include(${CPM_DOWNLOAD_LOCATION})
#####
#Suppress warning
cmake_policy(SET CMP0077 NEW)
# rapidjson
CPMAddPackage(
NAME rapidjson
GIT_TAG 949c771b03de448bdedea80c44a4a5f65284bfeb
GITHUB_REPOSITORY Tencent/rapidjson
OPTIONS
"RAPIDJSON_BUILD_CXX11 Off"
"RAPIDJSON_BUILD_CXX17 On"
)
if(rapidjson_ADDED)
add_library(rapidjson
INTERFACE IMPORTED
)
target_include_directories(rapidjson
SYSTEM INTERFACE ${rapidjson_SOURCE_DIR}/include
)
endif()
# cxxopts
CPMAddPackage(
NAME cxxopts
GITHUB_REPOSITORY jarro2783/cxxopts
VERSION 2.2.0
OPTIONS
"CXXOPTS_BUILD_EXAMPLES Off"
"CXXOPTS_BUILD_TESTS Off"
)
# spdlog
CPMAddPackage(
NAME spdlog
VERSION 1.7.0
GITHUB_REPOSITORY gabime/spdlog
)
#Set new timestamps
cmake_policy(SET CMP0135 NEW)
set(CMAKE_POLICY_DEFAULT_CMP0135 NEW)
# ranges
CPMAddPackage(
NAME range-v3
URL https://github.com/ericniebler/range-v3/archive/0.10.0.zip
VERSION 0.10.0
# the range-v3 CMakeLists screws with configuration options
DOWNLOAD_ONLY True
)
if(range-v3_ADDED)
add_library(range-v3
INTERFACE IMPORTED
)
target_include_directories(range-v3
SYSTEM INTERFACE ${range-v3_SOURCE_DIR}/include
)
endif()
# fmt
CPMAddPackage(
NAME fmt
GIT_TAG 6.2.1
GITHUB_REPOSITORY fmtlib/fmt
)
if(fmt_ADDED)
target_include_directories(fmt
SYSTEM INTERFACE ${fmt_SOURCE_DIR}/include
)
endif()
# glm
CPMAddPackage(
NAME glm
GIT_TAG 0.9.9.8
GITHUB_REPOSITORY g-truc/glm
)
# filesystem
CPMAddPackage(
NAME filesystem
GITHUB_REPOSITORY gulrak/filesystem
VERSION 1.3.4
)
if(filesystem_ADDED)
add_library(filesystem
INTERFACE IMPORTED
)
target_include_directories(filesystem
SYSTEM INTERFACE ${filesystem_SOURCE_DIR}/include
)
endif()
================================================
FILE: CMake-Utils/setup_python.cmake
================================================
function(add_python_library library)
add_library(${library} MODULE ${ARGN})
target_compile_options(${library}
INTERFACE "${CMAKE_CXX_FLAGS} -O3 -fuse-ld=lld
-fvisibility=hidden -fsized-deallocation") # -flto=thin -fsanitize=cfi
set_target_properties(${library}
PROPERTIES CPP_STANDARD 14
PREFIX "${PYTHON_MODULE_PREFIX}"
SUFFIX "${PYTHON_MODULE_EXTENSION}"
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
target_compile_definitions(${library}
INTERFACE CMAKE_GENERATOR_PLATFORM=x64
)
target_compile_features(${library} INTERFACE cxx_std_14)
target_link_libraries(${library}
PRIVATE pybind11::module
)
message("-- [${library}]\tpython library build config")
endfunction(add_python_library)
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.15) # support relative path
message("===============================================================")
include("project_info.in")
project(Mn
VERSION ${project_version}
DESCRIPTION ${project_description}
LANGUAGES CXX CUDA
)
option(BUILD_SHARED_LIBS "Enable compilation of shared libraries" OFF)
#Fixes https://gitlab.kitware.com/cmake/cmake/-/issues/24154 for older cmake versions
set(CMAKE_INCLUDE_SYSTEM_FLAG_CUDA "-isystem ")
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMake)
include(CMake-Utils/setup_cpp.cmake)
include(CMake-Utils/setup_cuda.cmake)
include(CMake-Utils/setup_externallibs.cmake)
add_subdirectory(Externals)
# header only libraries
include_directories(
SYSTEM
Externals/variant
Externals/optional
Externals/function_ref
)
message("===============================================================")
include_directories(Library)
add_subdirectory(Library)
add_subdirectory(Projects)
================================================
FILE: Externals/CMakeLists.txt
================================================
find_package(Git)
include(FetchContent)
include(ExternalProject)
include(DownloadProject)
# partio
message("## building partio")
add_subdirectory(partio)
# optional
#FetchContent_Declare(
# optional
# GIT_REPOSITORY https://github.com/TartanLlama/optional.git
# GIT_TAG 83a0b49e5e9571438c3ebae638e9a37502911b8c
#)
#FetchContent_MakeAvailable(optional)
# function_ref
#FetchContent_Declare(
# function_ref
# GIT_REPOSITORY https://github.com/TartanLlama/function_ref.git
# GIT_TAG 556c2c3fbfc144971c01ba6d177aaab48cab6870
#)
##FetchContent_MakeAvailable(function_ref)
#if (NOT function_ref_POPULATED)
# FetchContent_Populate(function_ref)
#endif()
# variant
#FetchContent_Declare(
# variant
# GIT_REPOSITORY https://github.com/mpark/variant.git
# GIT_TAG 4988879a9f5a95d72308eca2b1779db6ed9b135d
#)
#FetchContent_MakeAvailable(variant)
================================================
FILE: Externals/SDFGen/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 2.6)
Project("SDFGen")
# Set the build type. Options are:
# Coverage : w/ debug symbols, w/o optimization, w/ code-coverage
# Debug : w/ debug symbols, w/o optimization
# Release : w/o debug symbols, w/ optimization
# RelWithDebInfo : w/ debug symbols, w/ optimization
# MinSizeRel : w/o debug symbols, w/ optimization, stripped binaries
# SET(CMAKE_BUILD_TYPE Coverage)
SET(CMAKE_BUILD_TYPE Release)
#set the default path for built executables to the "bin" directory
set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/bin)
#These flags might not work on every system, especially the release flags, comment out as needed
set(CMAKE_CXX_FLAGS "-O3")
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
set(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native")
#checks if VTK is available
find_package(VTK QUIET)
if(VTK_FOUND)
set(HAVE_VTK 1)
endif()
#Generates config.h replacing expressions in config.h.in with actual values
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/config.h.in"
"${CMAKE_CURRENT_SOURCE_DIR}/config.h"
)
add_executable(${PROJECT_NAME} main.cpp makelevelset3.cpp)
if(VTK_FOUND)
include_directories(${VTK_INCLUDE_DIRS})
target_link_libraries(${PROJECT_NAME} ${VTK_LIBRARIES})
endif()
================================================
FILE: Externals/SDFGen/README.md
================================================
# SDFGen
A simple commandline utility to generate grid-based signed distance field (level set) generator from triangle meshes, using code from Robert Bridson's website.
The MIT License (MIT)
Copyright (c) 2015, Christopher Batty
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: Externals/SDFGen/array1.h
================================================
#ifndef ARRAY1_H
#define ARRAY1_H
#include <algorithm>
#include <cstring>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <vector>
// In this file:
// Array1<T>: a dynamic 1D array for plain-old-data (not objects)
// WrapArray1<T>: a 1D array wrapper around an existing array (perhaps objects, perhaps data)
// For the most part std::vector operations are supported, though for the Wrap version
// note that memory is never allocated/deleted and constructor/destructors are never called
// from within the class, thus only shallow copies can be made and some operations such as
// resize() and push_back() are limited.
// Note: for the most part assertions are done with assert(), not exceptions...
// gross template hacking to determine if a type is integral or not
struct Array1True {};
struct Array1False {};
template<typename T> struct Array1IsIntegral{ typedef Array1False type; }; // default: no (specializations to yes follow)
template<> struct Array1IsIntegral<bool>{ typedef Array1True type; };
template<> struct Array1IsIntegral<char>{ typedef Array1True type; };
template<> struct Array1IsIntegral<signed char>{ typedef Array1True type; };
template<> struct Array1IsIntegral<unsigned char>{ typedef Array1True type; };
template<> struct Array1IsIntegral<short>{ typedef Array1True type; };
template<> struct Array1IsIntegral<unsigned short>{ typedef Array1True type; };
template<> struct Array1IsIntegral<int>{ typedef Array1True type; };
template<> struct Array1IsIntegral<unsigned int>{ typedef Array1True type; };
template<> struct Array1IsIntegral<long>{ typedef Array1True type; };
template<> struct Array1IsIntegral<unsigned long>{ typedef Array1True type; };
template<> struct Array1IsIntegral<long long>{ typedef Array1True type; };
template<> struct Array1IsIntegral<unsigned long long>{ typedef Array1True type; };
//============================================================================
template<typename T>
struct Array1
{
// STL-friendly typedefs
typedef T* iterator;
typedef const T* const_iterator;
typedef unsigned long size_type;
typedef long difference_type;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// the actual representation
unsigned long n;
unsigned long max_n;
T* data;
// STL vector's interface, with additions, but only valid when used with plain-old-data
Array1(void)
: n(0), max_n(0), data(0)
{}
// note: default initial values are zero
Array1(unsigned long n_)
: n(0), max_n(0), data(0)
{
if(n_>ULONG_MAX/sizeof(T)) throw std::bad_alloc();
data=(T*)std::calloc(n_, sizeof(T));
if(!data) throw std::bad_alloc();
n=n_;
max_n=n_;
}
Array1(unsigned long n_, const T& value)
: n(0), max_n(0), data(0)
{
if(n_>ULONG_MAX/sizeof(T)) throw std::bad_alloc();
data=(T*)std::calloc(n_, sizeof(T));
if(!data) throw std::bad_alloc();
n=n_;
max_n=n_;
for(unsigned long i=0; i<n; ++i) data[i]=value;
}
Array1(unsigned long n_, const T& value, unsigned long max_n_)
: n(0), max_n(0), data(0)
{
assert(n_<=max_n_);
if(max_n_>ULONG_MAX/sizeof(T)) throw std::bad_alloc();
data=(T*)std::calloc(max_n_, sizeof(T));
if(!data) throw std::bad_alloc();
n=n_;
max_n=max_n_;
for(unsigned long i=0; i<n; ++i) data[i]=value;
}
Array1(unsigned long n_, const T* data_)
: n(0), max_n(0), data(0)
{
if(n_>ULONG_MAX/sizeof(T)) throw std::bad_alloc();
data=(T*)std::calloc(n_, sizeof(T));
if(!data) throw std::bad_alloc();
n=n_;
max_n=n_;
assert(data_);
std::memcpy(data, data_, n*sizeof(T));
}
Array1(unsigned long n_, const T* data_, unsigned long max_n_)
: n(0), max_n(0), data(0)
{
assert(n_<=max_n_);
if(max_n_>ULONG_MAX/sizeof(T)) throw std::bad_alloc();
data=(T*)std::calloc(max_n_, sizeof(T));
if(!data) throw std::bad_alloc();
max_n=max_n_;
n=n_;
assert(data_);
std::memcpy(data, data_, n*sizeof(T));
}
Array1(const Array1<T> &x)
: n(0), max_n(0), data(0)
{
data=(T*)std::malloc(x.n*sizeof(T));
if(!data) throw std::bad_alloc();
n=x.n;
max_n=x.n;
std::memcpy(data, x.data, n*sizeof(T));
}
~Array1(void)
{
std::free(data);
#ifndef NDEBUG
data=0;
n=max_n=0;
#endif
}
const T& operator[](unsigned long i) const
{ return data[i]; }
T& operator[](unsigned long i)
{ return data[i]; }
// these are range-checked (in debug mode) versions of operator[], like at()
const T& operator()(unsigned long i) const
{
assert(i<n);
return data[i];
}
T& operator()(unsigned long i)
{
assert(i<n);
return data[i];
}
Array1<T>& operator=(const Array1<T>& x)
{
if(max_n<x.n){
T* new_data=(T*)std::malloc(x.n*sizeof(T));
if(!new_data) throw std::bad_alloc();
std::free(data);
data=new_data;
max_n=x.n;
}
n=x.n;
std::memcpy(data, x.data, n*sizeof(T));
return *this;
}
bool operator==(const Array1<T>& x) const
{
if(n!=x.n) return false;
for(unsigned long i=0; i<n; ++i) if(!(data[i]==x.data[i])) return false;
return true;
}
bool operator!=(const Array1<T>& x) const
{
if(n!=x.n) return true;
for(unsigned long i=0; i<n; ++i) if(data[i]!=x.data[i]) return true;
return false;
}
bool operator<(const Array1<T>& x) const
{
for(unsigned long i=0; i<n && i<x.n; ++i){
if(data[i]<x[i]) return true;
else if(x[i]<data[i]) return false;
}
return n<x.n;
}
bool operator>(const Array1<T>& x) const
{
for(unsigned long i=0; i<n && i<x.n; ++i){
if(data[i]>x[i]) return true;
else if(x[i]>data[i]) return false;
}
return n>x.n;
}
bool operator<=(const Array1<T>& x) const
{
for(unsigned long i=0; i<n && i<x.n; ++i){
if(data[i]<x[i]) return true;
else if(x[i]<data[i]) return false;
}
return n<=x.n;
}
bool operator>=(const Array1<T>& x) const
{
for(unsigned long i=0; i<n && i<x.n; ++i){
if(data[i]>x[i]) return true;
else if(x[i]>data[i]) return false;
}
return n>=x.n;
}
void add_unique(const T& value)
{
for(unsigned long i=0; i<n; ++i) if(data[i]==value) return;
if(n==max_n) grow();
data[n++]=value;
}
void assign(const T& value)
{ for(unsigned long i=0; i<n; ++i) data[i]=value; }
void assign(unsigned long num, const T& value)
{ fill(num, value); }
// note: copydata may not alias this array's data, and this should not be
// used when T is a full object (which defines its own copying operation)
void assign(unsigned long num, const T* copydata)
{
assert(num==0 || copydata);
if(num>max_n){
if(num>ULONG_MAX/sizeof(T)) throw std::bad_alloc();
std::free(data);
data=(T*)std::malloc(num*sizeof(T));
if(!data) throw std::bad_alloc();
max_n=num;
}
n=num;
std::memcpy(data, copydata, n*sizeof(T));
}
template<typename InputIterator>
void assign(InputIterator first, InputIterator last)
{ assign_(first, last, typename Array1IsIntegral<InputIterator>::type()); }
template<typename InputIterator>
void assign_(InputIterator first, InputIterator last, Array1True check)
{ fill(first, last); }
template<typename InputIterator>
void assign_(InputIterator first, InputIterator last, Array1False check)
{
unsigned long i=0;
InputIterator p=first;
for(; p!=last; ++p, ++i){
if(i==max_n) grow();
data[i]=*p;
}
n=i;
}
const T& at(unsigned long i) const
{
assert(i<n);
return data[i];
}
T& at(unsigned long i)
{
assert(i<n);
return data[i];
}
const T& back(void) const
{
assert(data && n>0);
return data[n-1];
}
T& back(void)
{
assert(data && n>0);
return data[n-1];
}
const T* begin(void) const
{ return data; }
T* begin(void)
{ return data; }
unsigned long capacity(void) const
{ return max_n; }
void clear(void)
{
std::free(data);
data=0;
max_n=0;
n=0;
}
bool empty(void) const
{ return n==0; }
const T* end(void) const
{ return data+n; }
T* end(void)
{ return data+n; }
void erase(unsigned long index)
{
assert(index<n);
for(unsigned long i=index; i<n-1; ++i)
data[i]=data[i-1];
pop_back();
}
void fill(unsigned long num, const T& value)
{
if(num>max_n){
if(num>ULONG_MAX/sizeof(T)) throw std::bad_alloc();
std::free(data);
data=(T*)std::malloc(num*sizeof(T));
if(!data) throw std::bad_alloc();
max_n=num;
}
n=num;
for(unsigned long i=0; i<n; ++i) data[i]=value;
}
const T& front(void) const
{
assert(n>0);
return *data;
}
T& front(void)
{
assert(n>0);
return *data;
}
void grow(void)
{
unsigned long new_size=(max_n*sizeof(T)<ULONG_MAX/2 ? 2*max_n+1 : ULONG_MAX/sizeof(T));
T *new_data=(T*)std::realloc(data, new_size*sizeof(T));
if(!new_data) throw std::bad_alloc();
data=new_data;
max_n=new_size;
}
void insert(unsigned long index, const T& entry)
{
assert(index<=n);
push_back(back());
for(unsigned long i=n-1; i>index; --i)
data[i]=data[i-1];
data[index]=entry;
}
unsigned long max_size(void) const
{ return ULONG_MAX/sizeof(T); }
void pop_back(void)
{
assert(n>0);
--n;
}
void push_back(const T& value)
{
if(n==max_n) grow();
data[n++]=value;
}
reverse_iterator rbegin(void)
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin(void) const
{ return const_reverse_iterator(end()); }
reverse_iterator rend(void)
{ return reverse_iterator(begin()); }
const_reverse_iterator rend(void) const
{ return const_reverse_iterator(begin()); }
void reserve(unsigned long r)
{
if(r>ULONG_MAX/sizeof(T)) throw std::bad_alloc();
T *new_data=(T*)std::realloc(data, r*sizeof(T));
if(!new_data) throw std::bad_alloc();
data=new_data;
max_n=r;
}
void resize(unsigned long n_)
{
if(n_>max_n) reserve(n_);
n=n_;
}
void resize(unsigned long n_, const T& value)
{
if(n_>max_n) reserve(n_);
if(n<n_) for(unsigned long i=n; i<n_; ++i) data[i]=value;
n=n_;
}
void set_zero(void)
{ std::memset(data, 0, n*sizeof(T)); }
unsigned long size(void) const
{ return n; }
void swap(Array1<T>& x)
{
std::swap(n, x.n);
std::swap(max_n, x.max_n);
std::swap(data, x.data);
}
// resize the array to avoid wasted space, without changing contents
// (Note: realloc, at least on some platforms, will not do the trick)
void trim(void)
{
if(n==max_n) return;
T *new_data=(T*)std::malloc(n*sizeof(T));
if(!new_data) return;
std::memcpy(new_data, data, n*sizeof(T));
std::free(data);
data=new_data;
max_n=n;
}
};
// some common arrays
typedef Array1<double> Array1d;
typedef Array1<float> Array1f;
typedef Array1<long long> Array1ll;
typedef Array1<unsigned long long> Array1ull;
typedef Array1<int> Array1i;
typedef Array1<unsigned int> Array1ui;
typedef Array1<short> Array1s;
typedef Array1<unsigned short> Array1us;
typedef Array1<char> Array1c;
typedef Array1<unsigned char> Array1uc;
//============================================================================
template<typename T>
struct WrapArray1
{
// STL-friendly typedefs
typedef T* iterator;
typedef const T* const_iterator;
typedef unsigned long size_type;
typedef long difference_type;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// the actual representation
unsigned long n;
unsigned long max_n;
T* data;
// most of STL vector's interface, with a few changes
WrapArray1(void)
: n(0), max_n(0), data(0)
{}
WrapArray1(unsigned long n_, T* data_)
: n(n_), max_n(n_), data(data_)
{ assert(data || max_n==0); }
WrapArray1(unsigned long n_, T* data_, unsigned long max_n_)
: n(n_), max_n(max_n_), data(data_)
{
assert(n<=max_n);
assert(data || max_n==0);
}
// Allow for simple shallow copies of existing arrays
// Note that if the underlying arrays change where their data is, the WrapArray may be screwed up
WrapArray1(Array1<T>& a)
: n(a.n), max_n(a.max_n), data(a.data)
{}
WrapArray1(std::vector<T>& a)
: n(a.size()), max_n(a.capacity()), data(&a[0])
{}
void init(unsigned long n_, T* data_, unsigned long max_n_)
{
assert(n_<=max_n_);
assert(data_ || max_n_==0);
n=n_;
max_n=max_n_;
data=data_;
}
const T& operator[](unsigned long i) const
{ return data[i]; }
T& operator[](unsigned long i)
{ return data[i]; }
// these are range-checked (in debug mode) versions of operator[], like at()
const T& operator()(unsigned long i) const
{
assert(i<n);
return data[i];
}
T& operator()(unsigned long i)
{
assert(i<n);
return data[i];
}
bool operator==(const WrapArray1<T>& x) const
{
if(n!=x.n) return false;
for(unsigned long i=0; i<n; ++i) if(!(data[i]==x.data[i])) return false;
return true;
}
bool operator!=(const WrapArray1<T>& x) const
{
if(n!=x.n) return true;
for(unsigned long i=0; i<n; ++i) if(data[i]!=x.data[i]) return true;
return false;
}
bool operator<(const WrapArray1<T>& x) const
{
for(unsigned long i=0; i<n && i<x.n; ++i){
if(data[i]<x[i]) return true;
else if(x[i]<data[i]) return false;
}
return n<x.n;
}
bool operator>(const WrapArray1<T>& x) const
{
for(unsigned long i=0; i<n && i<x.n; ++i){
if(data[i]>x[i]) return true;
else if(x[i]>data[i]) return false;
}
return n>x.n;
}
bool operator<=(const WrapArray1<T>& x) const
{
for(unsigned long i=0; i<n && i<x.n; ++i){
if(data[i]<x[i]) return true;
else if(x[i]<data[i]) return false;
}
return n<=x.n;
}
bool operator>=(const WrapArray1<T>& x) const
{
for(unsigned long i=0; i<n && i<x.n; ++i){
if(data[i]>x[i]) return true;
else if(x[i]>data[i]) return false;
}
return n>=x.n;
}
void add_unique(const T& value)
{
for(unsigned long i=0; i<n; ++i) if(data[i]==value) return;
assert(n<max_n);
data[n++]=value;
}
void assign(const T& value)
{ for(unsigned long i=0; i<n; ++i) data[i]=value; }
void assign(unsigned long num, const T& value)
{ fill(num, value); }
// note: copydata may not alias this array's data, and this should not be
// used when T is a full object (which defines its own copying operation)
void assign(unsigned long num, const T* copydata)
{
assert(num==0 || copydata);
assert(num<=max_n);
n=num;
std::memcpy(data, copydata, n*sizeof(T));
}
template<typename InputIterator>
void assign(InputIterator first, InputIterator last)
{ assign_(first, last, typename Array1IsIntegral<InputIterator>::type()); }
template<typename InputIterator>
void assign_(InputIterator first, InputIterator last, Array1True check)
{ fill(first, last); }
template<typename InputIterator>
void assign_(InputIterator first, InputIterator last, Array1False check)
{
unsigned long i=0;
InputIterator p=first;
for(; p!=last; ++p, ++i){
assert(i<max_n);
data[i]=*p;
}
n=i;
}
const T& at(unsigned long i) const
{
assert(i<n);
return data[i];
}
T& at(unsigned long i)
{
assert(i<n);
return data[i];
}
const T& back(void) const
{
assert(data && n>0);
return data[n-1];
}
T& back(void)
{
assert(data && n>0);
return data[n-1];
}
const T* begin(void) const
{ return data; }
T* begin(void)
{ return data; }
unsigned long capacity(void) const
{ return max_n; }
void clear(void)
{ n=0; }
bool empty(void) const
{ return n==0; }
const T* end(void) const
{ return data+n; }
T* end(void)
{ return data+n; }
void erase(unsigned long index)
{
assert(index<n);
for(unsigned long i=index; i<n-1; ++i)
data[i]=data[i-1];
pop_back();
}
void fill(unsigned long num, const T& value)
{
assert(num<=max_n);
n=num;
for(unsigned long i=0; i<n; ++i) data[i]=value;
}
const T& front(void) const
{
assert(n>0);
return *data;
}
T& front(void)
{
assert(n>0);
return *data;
}
void insert(unsigned long index, const T& entry)
{
assert(index<=n);
push_back(back());
for(unsigned long i=n-1; i>index; --i)
data[i]=data[i-1];
data[index]=entry;
}
unsigned long max_size(void) const
{ return max_n; }
void pop_back(void)
{
assert(n>0);
--n;
}
void push_back(const T& value)
{
assert(n<max_n);
data[n++]=value;
}
reverse_iterator rbegin(void)
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin(void) const
{ return const_reverse_iterator(end()); }
reverse_iterator rend(void)
{ return reverse_iterator(begin()); }
const_reverse_iterator rend(void) const
{ return const_reverse_iterator(begin()); }
void reserve(unsigned long r)
{ assert(r<=max_n); }
void resize(unsigned long n_)
{
assert(n_<=max_n);
n=n_;
}
void resize(unsigned long n_, const T& value)
{
assert(n_<=max_n);
if(n<n_) for(unsigned long i=n; i<n_; ++i) data[i]=value;
n=n_;
}
// note: shouldn't be used when T is a full object (setting to zero may not make sense)
void set_zero(void)
{ std::memset(data, 0, n*sizeof(T)); }
unsigned long size(void) const
{ return n; }
void swap(WrapArray1<T>& x)
{
std::swap(n, x.n);
std::swap(max_n, x.max_n);
std::swap(data, x.data);
}
};
// some common arrays
typedef WrapArray1<double> WrapArray1d;
typedef WrapArray1<float> WrapArray1f;
typedef WrapArray1<long long> WrapArray1ll;
typedef WrapArray1<unsigned long long> WrapArray1ull;
typedef WrapArray1<int> WrapArray1i;
typedef WrapArray1<unsigned int> WrapArray1ui;
typedef WrapArray1<short> WrapArray1s;
typedef WrapArray1<unsigned short> WrapArray1us;
typedef WrapArray1<char> WrapArray1c;
typedef WrapArray1<unsigned char> WrapArray1uc;
#endif
================================================
FILE: Externals/SDFGen/array2.h
================================================
#ifndef ARRAY2_H
#define ARRAY2_H
#include "array1.h"
#include <algorithm>
#include <cassert>
#include <vector>
template<class T, class ArrayT=std::vector<T> >
struct Array2
{
// STL-friendly typedefs
typedef typename ArrayT::iterator iterator;
typedef typename ArrayT::const_iterator const_iterator;
typedef typename ArrayT::size_type size_type;
typedef long difference_type;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef typename ArrayT::reverse_iterator reverse_iterator;
typedef typename ArrayT::const_reverse_iterator const_reverse_iterator;
// the actual representation
int ni, nj;
ArrayT a;
// the interface
Array2(void)
: ni(0), nj(0)
{}
Array2(int ni_, int nj_)
: ni(ni_), nj(nj_), a(ni_*nj_)
{ assert(ni_>=0 && nj>=0); }
Array2(int ni_, int nj_, ArrayT& a_)
: ni(ni_), nj(nj_), a(a_)
{ assert(ni_>=0 && nj>=0); }
Array2(int ni_, int nj_, const T& value)
: ni(ni_), nj(nj_), a(ni_*nj_, value)
{ assert(ni_>=0 && nj>=0); }
Array2(int ni_, int nj_, const T& value, size_type max_n_)
: ni(ni_), nj(nj_), a(ni_*nj_, value, max_n_)
{ assert(ni_>=0 && nj>=0); }
Array2(int ni_, int nj_, T* data_)
: ni(ni_), nj(nj_), a(ni_*nj_, data_)
{ assert(ni_>=0 && nj>=0); }
Array2(int ni_, int nj_, T* data_, size_type max_n_)
: ni(ni_), nj(nj_), a(ni_*nj_, data_, max_n_)
{ assert(ni_>=0 && nj>=0); }
template<class OtherArrayT>
Array2(Array2<T, OtherArrayT>& other)
: ni(other.ni), nj(other.nj), a(other.a)
{}
~Array2(void)
{
#ifndef NDEBUG
ni=nj=0;
#endif
}
const T& operator()(int i, int j) const
{
assert(i>=0 && i<ni && j>=0 && j<nj);
return a[i+ni*j];
}
T& operator()(int i, int j)
{
assert(i>=0 && i<ni && j>=0 && j<nj);
return a[i+ni*j];
}
bool operator==(const Array2<T>& x) const
{ return ni==x.ni && nj==x.nj && a==x.a; }
bool operator!=(const Array2<T>& x) const
{ return ni!=x.ni || nj!=x.nj || a!=x.a; }
bool operator<(const Array2<T>& x) const
{
if(ni<x.ni) return true; else if(ni>x.ni) return false;
if(nj<x.nj) return true; else if(nj>x.nj) return false;
return a<x.a;
}
bool operator>(const Array2<T>& x) const
{
if(ni>x.ni) return true; else if(ni<x.ni) return false;
if(nj>x.nj) return true; else if(nj<x.nj) return false;
return a>x.a;
}
bool operator<=(const Array2<T>& x) const
{
if(ni<x.ni) return true; else if(ni>x.ni) return false;
if(nj<x.nj) return true; else if(nj>x.nj) return false;
return a<=x.a;
}
bool operator>=(const Array2<T>& x) const
{
if(ni>x.ni) return true; else if(ni<x.ni) return false;
if(nj>x.nj) return true; else if(nj<x.nj) return false;
return a>=x.a;
}
void assign(const T& value)
{ a.assign(value); }
void assign(int ni_, int nj_, const T& value)
{
a.assign(ni_*nj_, value);
ni=ni_;
nj=nj_;
}
void assign(int ni_, int nj_, const T* copydata)
{
a.assign(ni_*nj_, copydata);
ni=ni_;
nj=nj_;
}
const T& at(int i, int j) const
{
assert(i>=0 && i<ni && j>=0 && j<nj);
return a[i+ni*j];
}
T& at(int i, int j)
{
assert(i>=0 && i<ni && j>=0 && j<nj);
return a[i+ni*j];
}
const T& back(void) const
{
assert(a.size());
return a.back();
}
T& back(void)
{
assert(a.size());
return a.back();
}
const_iterator begin(void) const
{ return a.begin(); }
iterator begin(void)
{ return a.begin(); }
size_type capacity(void) const
{ return a.capacity(); }
void clear(void)
{
a.clear();
ni=nj=0;
}
bool empty(void) const
{ return a.empty(); }
const_iterator end(void) const
{ return a.end(); }
iterator end(void)
{ return a.end(); }
void fill(int ni_, int nj_, const T& value)
{
a.fill(ni_*nj_, value);
ni=ni_;
nj=nj_;
}
const T& front(void) const
{
assert(a.size());
return a.front();
}
T& front(void)
{
assert(a.size());
return a.front();
}
size_type max_size(void) const
{ return a.max_size(); }
reverse_iterator rbegin(void)
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin(void) const
{ return const_reverse_iterator(end()); }
reverse_iterator rend(void)
{ return reverse_iterator(begin()); }
const_reverse_iterator rend(void) const
{ return const_reverse_iterator(begin()); }
void reserve(int reserve_ni, int reserve_nj)
{ a.reserve(reserve_ni*reserve_nj); }
void resize(int ni_, int nj_)
{
assert(ni_>=0 && nj_>=0);
a.resize(ni_*nj_);
ni=ni_;
nj=nj_;
}
void resize(int ni_, int nj_, const T& value)
{
assert(ni_>=0 && nj_>=0);
a.resize(ni_*nj_, value);
ni=ni_;
nj=nj_;
}
void set_zero(void)
{ a.set_zero(); }
size_type size(void) const
{ return a.size(); }
void swap(Array2<T>& x)
{
std::swap(ni, x.ni);
std::swap(nj, x.nj);
a.swap(x.a);
}
void trim(void)
{ a.trim(); }
};
// some common arrays
typedef Array2<double, Array1<double> > Array2d;
typedef Array2<float, Array1<float> > Array2f;
typedef Array2<long long, Array1<long long> > Array2ll;
typedef Array2<unsigned long long, Array1<unsigned long long> > Array2ull;
typedef Array2<int, Array1<int> > Array2i;
typedef Array2<unsigned int, Array1<unsigned int> > Array2ui;
typedef Array2<short, Array1<short> > Array2s;
typedef Array2<unsigned short, Array1<unsigned short> > Array2us;
typedef Array2<char, Array1<char> > Array2c;
typedef Array2<unsigned char, Array1<unsigned char> > Array2uc;
// and wrapped versions
typedef Array2<double, WrapArray1<double> > WrapArray2d;
typedef Array2<float, WrapArray1<float> > WrapArray2f;
typedef Array2<long long, WrapArray1<long long> > WrapArray2ll;
typedef Array2<unsigned long long, WrapArray1<unsigned long long> > WrapArray2ull;
typedef Array2<int, WrapArray1<int> > WrapArray2i;
typedef Array2<unsigned int, WrapArray1<unsigned int> > WrapArray2ui;
typedef Array2<short, WrapArray1<short> > WrapArray2s;
typedef Array2<unsigned short, WrapArray1<unsigned short> > WrapArray2us;
typedef Array2<char, WrapArray1<char> > WrapArray2c;
typedef Array2<unsigned char, WrapArray1<unsigned char> > WrapArray2uc;
#endif
================================================
FILE: Externals/SDFGen/array3.h
================================================
#ifndef ARRAY3_H
#define ARRAY3_H
#include "array1.h"
#include <algorithm>
#include <cassert>
#include <vector>
template<class T, class ArrayT=std::vector<T> >
struct Array3
{
// STL-friendly typedefs
typedef typename ArrayT::iterator iterator;
typedef typename ArrayT::const_iterator const_iterator;
typedef typename ArrayT::size_type size_type;
typedef long difference_type;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef typename ArrayT::reverse_iterator reverse_iterator;
typedef typename ArrayT::const_reverse_iterator const_reverse_iterator;
// the actual representation
int ni, nj, nk;
ArrayT a;
// the interface
Array3(void)
: ni(0), nj(0), nk(0)
{}
Array3(int ni_, int nj_, int nk_)
: ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_)
{ assert(ni_>=0 && nj_>=0 && nk_>=0); }
Array3(int ni_, int nj_, int nk_, ArrayT& a_)
: ni(ni_), nj(nj_), nk(nk_), a(a_)
{ assert(ni_>=0 && nj_>=0 && nk_>=0); }
Array3(int ni_, int nj_, int nk_, const T& value)
: ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, value)
{ assert(ni_>=0 && nj_>=0 && nk_>=0); }
Array3(int ni_, int nj_, int nk_, const T& value, size_type max_n_)
: ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, value, max_n_)
{ assert(ni_>=0 && nj_>=0 && nk_>=0); }
Array3(int ni_, int nj_, int nk_, T* data_)
: ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, data_)
{ assert(ni_>=0 && nj_>=0 && nk_>=0); }
Array3(int ni_, int nj_, int nk_, T* data_, size_type max_n_)
: ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, data_, max_n_)
{ assert(ni_>=0 && nj_>=0 && nk_>=0); }
~Array3(void)
{
#ifndef NDEBUG
ni=nj=0;
#endif
}
const T& operator()(int i, int j, int k) const
{
assert(i>=0 && i<ni && j>=0 && j<nj && k>=0 && k<nk);
return a[i+ni*(j+nj*k)];
}
T& operator()(int i, int j, int k)
{
assert(i>=0 && i<ni && j>=0 && j<nj && k>=0 && k<nk);
return a[i+ni*(j+nj*k)];
}
bool operator==(const Array3<T>& x) const
{ return ni==x.ni && nj==x.nj && nk==x.nk && a==x.a; }
bool operator!=(const Array3<T>& x) const
{ return ni!=x.ni || nj!=x.nj || nk!=x.nk || a!=x.a; }
bool operator<(const Array3<T>& x) const
{
if(ni<x.ni) return true; else if(ni>x.ni) return false;
if(nj<x.nj) return true; else if(nj>x.nj) return false;
if(nk<x.nk) return true; else if(nk>x.nk) return false;
return a<x.a;
}
bool operator>(const Array3<T>& x) const
{
if(ni>x.ni) return true; else if(ni<x.ni) return false;
if(nj>x.nj) return true; else if(nj<x.nj) return false;
if(nk>x.nk) return true; else if(nk<x.nk) return false;
return a>x.a;
}
bool operator<=(const Array3<T>& x) const
{
if(ni<x.ni) return true; else if(ni>x.ni) return false;
if(nj<x.nj) return true; else if(nj>x.nj) return false;
if(nk<x.nk) return true; else if(nk>x.nk) return false;
return a<=x.a;
}
bool operator>=(const Array3<T>& x) const
{
if(ni>x.ni) return true; else if(ni<x.ni) return false;
if(nj>x.nj) return true; else if(nj<x.nj) return false;
if(nk>x.nk) return true; else if(nk<x.nk) return false;
return a>=x.a;
}
void assign(const T& value)
{ a.assign(value); }
void assign(int ni_, int nj_, int nk_, const T& value)
{
a.assign(ni_*nj_*nk_, value);
ni=ni_;
nj=nj_;
nk=nk_;
}
void assign(int ni_, int nj_, int nk_, const T* copydata)
{
a.assign(ni_*nj_*nk_, copydata);
ni=ni_;
nj=nj_;
nk=nk_;
}
const T& at(int i, int j, int k) const
{
assert(i>=0 && i<ni && j>=0 && j<nj && k>=0 && k<nk);
return a[i+ni*(j+nj*k)];
}
T& at(int i, int j, int k)
{
assert(i>=0 && i<ni && j>=0 && j<nj && k>=0 && k<nk);
return a[i+ni*(j+nj*k)];
}
const T& back(void) const
{
assert(a.size());
return a.back();
}
T& back(void)
{
assert(a.size());
return a.back();
}
const_iterator begin(void) const
{ return a.begin(); }
iterator begin(void)
{ return a.begin(); }
size_type capacity(void) const
{ return a.capacity(); }
void clear(void)
{
a.clear();
ni=nj=nk=0;
}
bool empty(void) const
{ return a.empty(); }
const_iterator end(void) const
{ return a.end(); }
iterator end(void)
{ return a.end(); }
void fill(int ni_, int nj_, int nk_, const T& value)
{
a.fill(ni_*nj_*nk_, value);
ni=ni_;
nj=nj_;
nk=nk_;
}
const T& front(void) const
{
assert(a.size());
return a.front();
}
T& front(void)
{
assert(a.size());
return a.front();
}
size_type max_size(void) const
{ return a.max_size(); }
reverse_iterator rbegin(void)
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin(void) const
{ return const_reverse_iterator(end()); }
reverse_iterator rend(void)
{ return reverse_iterator(begin()); }
const_reverse_iterator rend(void) const
{ return const_reverse_iterator(begin()); }
void reserve(int reserve_ni, int reserve_nj, int reserve_nk)
{ a.reserve(reserve_ni*reserve_nj*reserve_nk); }
void resize(int ni_, int nj_, int nk_)
{
assert(ni_>=0 && nj_>=0 && nk_>=0);
a.resize(ni_*nj_*nk_);
ni=ni_;
nj=nj_;
nk=nk_;
}
void resize(int ni_, int nj_, int nk_, const T& value)
{
assert(ni_>=0 && nj_>=0 && nk_>=0);
a.resize(ni_*nj_*nk_, value);
ni=ni_;
nj=nj_;
nk=nk_;
}
void set_zero(void)
{ a.set_zero(); }
size_type size(void) const
{ return a.size(); }
void swap(Array3<T>& x)
{
std::swap(ni, x.ni);
std::swap(nj, x.nj);
std::swap(nk, x.nk);
a.swap(x.a);
}
void trim(void)
{ a.trim(); }
};
// some common arrays
typedef Array3<double, Array1<double> > Array3d;
typedef Array3<float, Array1<float> > Array3f;
typedef Array3<long long, Array1<long long> > Array3ll;
typedef Array3<unsigned long long, Array1<unsigned long long> > Array3ull;
typedef Array3<int, Array1<int> > Array3i;
typedef Array3<unsigned int, Array1<unsigned int> > Array3ui;
typedef Array3<short, Array1<short> > Array3s;
typedef Array3<unsigned short, Array1<unsigned short> > Array3us;
typedef Array3<char, Array1<char> > Array3c;
typedef Array3<unsigned char, Array1<unsigned char> > Array3uc;
#endif
================================================
FILE: Externals/SDFGen/config.h.in
================================================
#ifndef SDFGEN_CONFIG_H
#define SDFGEN_CONFIG_H
/*
* Configuration Header for SDFGEN
*/
/// Configured libraries
#cmakedefine HAVE_VTK
#endif //SDFGEN_CONFIG_H
================================================
FILE: Externals/SDFGen/hashgrid.h
================================================
#ifndef HASHGRID_H
#define HASHGRID_H
#include "hashtable.h"
#include "vec.h"
//========================================================= first do 2D ============================
template<class DataType>
struct HashGrid2
{
double dx, overdx; // side-length of a grid cell and its reciprocal
HashTable<Vec2i,DataType> grid;
explicit HashGrid2(double dx_=1, int expected_size=512)
: dx(dx_), overdx(1/dx_), grid(expected_size)
{}
// only do this with an empty grid
void set_grid_size(double dx_)
{ assert(size()==0); dx=dx_; overdx=1/dx; }
void add_point(const Vec2d &x, const DataType &datum)
{ grid.add(round(x*overdx), datum); }
void delete_point(const Vec2d &x, const DataType &datum)
{ grid.delete_entry(round(x*overdx), datum); }
void add_box(const Vec2d &xmin, const Vec2d &xmax, const DataType &datum)
{
Vec2i imin=round(xmin*overdx), imax=round(xmax*overdx);
for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i)
grid.add(Vec2i(i,j), datum);
}
void delete_box(const Vec2d &xmin, const Vec2d &xmax, const DataType &datum)
{
Vec2i imin=round(xmin*overdx), imax=round(xmax*overdx);
for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i)
grid.delete_entry(Vec2i(i,j), datum);
}
unsigned int size(void) const
{ return grid.size(); }
void clear(void)
{ grid.clear(); }
void reserve(unsigned int expected_size)
{ grid.reserve(expected_size); }
bool find_first_point(const Vec2d &x, DataType &datum) const
{ return grid.get_entry(round(x*overdx), datum); }
bool find_point(const Vec2d &x, std::vector<DataType> &data_list) const
{
data_list.resize(0);
grid.append_all_entries(round(x*overdx), data_list);
return data_list.size()>0;
}
bool find_box(const Vec2d &xmin, const Vec2d &xmax, std::vector<DataType> &data_list) const
{
data_list.resize(0);
Vec2i imin=round(xmin*overdx), imax=round(xmax*overdx);
for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i)
grid.append_all_entries(Vec2i(i,j), data_list);
return data_list.size()>0;
}
};
//==================================== and now in 3D =================================================
template<class DataType>
struct HashGrid3
{
double dx, overdx; // side-length of a grid cell and its reciprocal
HashTable<Vec3i,DataType> grid;
explicit HashGrid3(double dx_=1, int expected_size=512)
: dx(dx_), overdx(1/dx_), grid(expected_size)
{}
// only do this with an empty grid
void set_grid_size(double dx_)
{ assert(size()==0); dx=dx_; overdx=1/dx; }
void add_point(const Vec3d &x, const DataType &datum)
{ grid.add(round(x*overdx), datum); }
void delete_point(const Vec3d &x, const DataType &datum)
{ grid.delete_entry(round(x*overdx), datum); }
void add_box(const Vec3d &xmin, const Vec3d &xmax, const DataType &datum)
{
Vec3i imin=round(xmin*overdx), imax=round(xmax*overdx);
for(int k=imin[2]; k<=imax[2]; ++k) for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i)
grid.add(Vec3i(i,j,k), datum);
}
void delete_box(const Vec3d &xmin, const Vec3d &xmax, const DataType &datum)
{
Vec3i imin=round(xmin*overdx), imax=round(xmax*overdx);
for(int k=imin[2]; k<=imax[2]; ++k) for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i)
grid.delete_entry(Vec3i(i,j,k), datum);
}
unsigned int size(void) const
{ return grid.size(); }
void clear(void)
{ grid.clear(); }
void reserve(unsigned int expected_size)
{ grid.reserve(expected_size); }
bool find_first_point(const Vec3d &x, DataType &index) const
{ return grid.get_entry(round(x*overdx), index); }
bool find_point(const Vec3d &x, std::vector<DataType> &data_list) const
{
data_list.resize(0);
grid.append_all_entries(round(x*overdx), data_list);
return data_list.size()>0;
}
bool find_box(const Vec3d &xmin, const Vec3d &xmax, std::vector<DataType> &data_list) const
{
data_list.resize(0);
Vec3i imin=round(xmin*overdx), imax=round(xmax*overdx);
for(int k=imin[2]; k<=imax[2]; ++k) for(int j=imin[1]; j<=imax[1]; ++j) for(int i=imin[0]; i<=imax[0]; ++i)
grid.append_all_entries(Vec3i(i, j, k), data_list);
return data_list.size()>0;
}
};
#endif
================================================
FILE: Externals/SDFGen/hashtable.h
================================================
#ifndef HASHTABLE_H
#define HASHTABLE_H
#include <functional>
#include <iostream>
#include <vector>
template<class Key, class Data>
struct HashEntry
{
Key key;
Data data;
int next;
};
// a useful core hash function
inline unsigned int hash(unsigned int k)
{ return k*2654435769u; }
// default hash function object
struct DefaultHashFunction
{
template<typename Key>
unsigned int operator() (const Key &k) const { return hash(k); }
};
struct equal
{
template<typename T>
bool operator() (const T &a, const T &b) const { return a==b; }
};
template<typename Key, typename Data, class HashFunction=DefaultHashFunction, class KeyEqual=equal>
struct HashTable
{
unsigned int table_rank;
unsigned int table_bits;
std::vector<int> table;
unsigned int num_entries;
std::vector<HashEntry<Key, Data> > pool;
int free_list;
const HashFunction hash_function;
const KeyEqual key_equal;
explicit HashTable(unsigned int expected_size=64)
: hash_function(HashFunction()), key_equal(KeyEqual())
{ init(expected_size); }
explicit HashTable(const HashFunction &hf, unsigned int expected_size=64)
: hash_function(hf), key_equal(KeyEqual())
{ init(expected_size); }
void init(unsigned int expected_size)
{
unsigned int i;
num_entries=0;
table_rank=4;
while(1u<<table_rank < expected_size)
++table_rank;
++table_rank; // give us some extra room
table_bits=(1u<<table_rank)-1;
table.resize(1u<<table_rank);
for(i=0; i<table.size(); ++i)
table[i]=-1; // empty list
pool.resize(1u<<table_rank);
free_list=0;
for(unsigned int i=0; i<pool.size()-1; ++i)
pool[i].next=i+1;
pool[pool.size()-1].next=-1; // end of free list
}
void add(const Key &k, const Data &d)
{
if(free_list==-1)
reserve(1u<<(table_rank+1));
int i=free_list; // where we're going to put the new entry
free_list=pool[i].next;
unsigned int t=hash_function(k)&table_bits; // index into table
pool[i].key=k;
pool[i].data=d;
pool[i].next=table[t]; // put the new entry at the start of table[t]'s list
table[t]=i;
++num_entries;
}
void delete_entry(const Key &k, const Data &d) // delete first entry that matches both key and data
{
unsigned int t=hash_function(k)&table_bits;
int i=table[t], *p_i=&table[t];
while(i!=-1){
if(key_equal(k, pool[i].key) && d==pool[i].data){
*p_i=pool[i].next; // make list skip over this entry
pool[i].next=free_list; // and put it on the front of the free list
free_list=i;
return; // and we're done
}
p_i=&pool[i].next;
i=*p_i;
}
}
unsigned int size() const
{ return num_entries; }
void clear()
{
unsigned int i=0;
num_entries=0;
for(i=0; i<table.size(); ++i)
table[i]=-1; // empty list
free_list=0;
for(i=0; i<pool.size()-1; ++i)
pool[i].next=i+1;
pool[pool.size()-1].next=-1;
}
void reserve(unsigned int expected_size)
{
if(expected_size<=pool.size())
return;
while(1u<<table_rank < expected_size)
++table_rank;
table_bits=(1u<<table_rank)-1;
// increase room for new entries
unsigned int old_size=(unsigned int)pool.size(), i;
pool.resize(1u<<table_rank);
for(i=old_size; i<pool.size()-1; ++i)
pool[i].next=i+1;
pool[i].next=free_list;
free_list=old_size;
// And finally need to redo table (rehash entries)
old_size=(unsigned int)table.size();
table.resize(1u<<table_rank);
unsigned int t;
for(t=old_size; t<table.size(); ++t)
table[t]=-1; // initially make new lists empty
int j, *p_j;
for(t=0; t<old_size; ++t){
j=table[t];
p_j=&table[t];
while(j!=-1){
unsigned int new_t=hash_function(pool[j].key)&table_bits;
if(new_t!=t){ // j doesn't belong in this list anymore?
// delete from this list
*p_j=pool[j].next;
// add to correct list
pool[j].next=table[new_t];
table[new_t]=j;
}else
p_j=&(pool[j].next);
j=*p_j;
}
}
}
bool has_entry(const Key &k) const
{
unsigned int t=hash_function(k)&table_bits;
int i=table[t];
while(i!=-1){
if(key_equal(k, pool[i].key))
return true;
i=pool[i].next;
}
return false;
}
bool get_entry(const Key &k, Data &data_return) const
{
unsigned int t=hash_function(k)&table_bits;
int i=table[t];
while(i!=-1){
if(key_equal(k, pool[i].key)){
data_return=pool[i].data;
return true;
}
i=pool[i].next;
}
return false;
}
void append_all_entries(const Key& k, std::vector<Data>& data_return) const
{
unsigned int t=hash_function(k)&table_bits;
int i=table[t];
while(i!=-1){
if(key_equal(k, pool[i].key)) data_return.push_back(pool[i].data);
i=pool[i].next;
}
}
Data &operator() (const Key &k, const Data &missing_data)
{
unsigned int t=hash_function(k)&table_bits;
int i=table[t];
while(i!=-1){
if(key_equal(k, pool[i].key))
return pool[i].data;
i=pool[i].next;
}
add(k, missing_data); // note - this could cause the table to be resized, and t made out-of-date
return pool[table[hash_function(k)&table_bits]].data; // we know that add() puts it here!
}
const Data &operator() (const Key &k, const Data &missing_data) const
{
unsigned int t=hash_function(k)&table_bits;
int i=table[t];
while(i!=-1){
if(key_equal(k, pool[i].key))
return pool[i].data;
i=pool[i].next;
}
return missing_data;
}
void output_statistics() const
{
std::vector<int> lengthcount(table.size());
unsigned int t;
int total=0;
for(t=0; t<table.size(); ++t){
int i=table[t], length=0;
while(i!=-1){
++length;
i=pool[i].next;
}
++lengthcount[length];
++total;
}
int subtotal=0;
int maxlength=0;
for(t=0; t<lengthcount.size() && t<10; ++t){
subtotal+=lengthcount[t];
if(lengthcount[t]>0){
std::cout<<"length "<<t<<": "<<lengthcount[t]<<" ("<<lengthcount[t]/(float)total*100.0<<"%)"<<std::endl;
maxlength=t;
}
}
std::cout<<"rest: "<<total-subtotal<<" ("<<100.0*(1.0-subtotal/(float)total)<<"%)"<<std::endl;
for(; t<lengthcount.size(); ++t)
if(lengthcount[t]>0)
maxlength=t;
std::cout<<"longest list: "<<maxlength<<std::endl;
}
};
#endif
================================================
FILE: Externals/SDFGen/main.cpp
================================================
//SDFGen - A simple grid-based signed distance field (level set) generator for triangle meshes.
//Written by Christopher Batty (christopherbatty@yahoo.com, www.cs.columbia.edu/~batty)
//...primarily using code from Robert Bridson's website (www.cs.ubc.ca/~rbridson)
//This code is public domain. Feel free to mess with it, let me know if you like it.
#include "makelevelset3.h"
#include "config.h"
#ifdef HAVE_VTK
#include <vtkImageData.h>
#include <vtkFloatArray.h>
#include <vtkXMLImageDataWriter.h>
#include <vtkPointData.h>
#include <vtkSmartPointer.h>
#endif
#include <fstream>
#include <iostream>
#include <sstream>
#include <limits>
int main(int argc, char* argv[]) {
if(argc != 4) {
std::cout << "SDFGen - A utility for converting closed oriented triangle meshes into grid-based signed distance fields.\n";
std::cout << "\nThe output file format is:";
std::cout << "<ni> <nj> <nk>\n";
std::cout << "<origin_x> <origin_y> <origin_z>\n";
std::cout << "<dx>\n";
std::cout << "<value_1> <value_2> <value_3> [...]\n\n";
std::cout << "(ni,nj,nk) are the integer dimensions of the resulting distance field.\n";
std::cout << "(origin_x,origin_y,origin_z) is the 3D position of the grid origin.\n";
std::cout << "<dx> is the grid spacing.\n\n";
std::cout << "<value_n> are the signed distance data values, in ascending order of i, then j, then k.\n";
std::cout << "The output filename will match that of the input, with the OBJ suffix replaced with SDF.\n\n";
std::cout << "Usage: SDFGen <filename> <dx> <padding>\n\n";
std::cout << "Where:\n";
std::cout << "\t<filename> specifies a Wavefront OBJ (text) file representing a *triangle* mesh (no quad or poly meshes allowed). File must use the suffix \".obj\".\n";
std::cout << "\t<dx> specifies the length of grid cell in the resulting distance field.\n";
std::cout << "\t<padding> specifies the number of cells worth of padding between the object bound box and the boundary of the distance field grid. Minimum is 1.\n\n";
exit(-1);
}
std::string filename(argv[1]);
if(filename.size() < 5 || filename.substr(filename.size()-4) != std::string(".obj")) {
std::cerr << "Error: Expected OBJ file with filename of the form <name>.obj.\n";
exit(-1);
}
std::stringstream arg2(argv[2]);
float dx;
arg2 >> dx;
std::stringstream arg3(argv[3]);
int padding;
arg3 >> padding;
if(padding < 1) padding = 1;
//start with a massive inside out bound box.
Vec3f min_box(std::numeric_limits<float>::max(),std::numeric_limits<float>::max(),std::numeric_limits<float>::max()),
max_box(-std::numeric_limits<float>::max(),-std::numeric_limits<float>::max(),-std::numeric_limits<float>::max());
std::cout << "Reading data.\n";
std::ifstream infile(argv[1]);
if(!infile) {
std::cerr << "Failed to open. Terminating.\n";
exit(-1);
}
int ignored_lines = 0;
std::string line;
std::vector<Vec3f> vertList;
std::vector<Vec3ui> faceList;
while(!infile.eof()) {
std::getline(infile, line);
//.obj files sometimes contain vertex normals indicated by "vn"
if(line.substr(0,1) == std::string("v") && line.substr(0,2) != std::string("vn")){
std::stringstream data(line);
char c;
Vec3f point;
data >> c >> point[0] >> point[1] >> point[2];
vertList.push_back(point);
update_minmax(point, min_box, max_box);
}
else if(line.substr(0,1) == std::string("f")) {
std::stringstream data(line);
char c;
int v0,v1,v2;
data >> c >> v0 >> v1 >> v2;
faceList.push_back(Vec3ui(v0-1,v1-1,v2-1));
}
else if( line.substr(0,2) == std::string("vn") ){
std::cerr << "Obj-loader is not able to parse vertex normals, please strip them from the input file. \n";
exit(-2);
}
else {
++ignored_lines;
}
}
infile.close();
if(ignored_lines > 0)
std::cout << "Warning: " << ignored_lines << " lines were ignored since they did not contain faces or vertices.\n";
std::cout << "Read in " << vertList.size() << " vertices and " << faceList.size() << " faces." << std::endl;
//Add padding around the box.
Vec3f unit(1,1,1);
min_box -= padding*dx*unit;
max_box += padding*dx*unit;
Vec3ui sizes = Vec3ui((max_box - min_box)/dx);
std::cout << "Bound box size: (" << min_box << ") to (" << max_box << ") with dimensions " << sizes << "." << std::endl;
std::cout << "Computing signed distance field.\n";
Array3f phi_grid;
make_level_set3(faceList, vertList, min_box, dx, sizes[0], sizes[1], sizes[2], phi_grid);
std::string outname;
#ifdef HAVE_VTK
// If compiled with VTK, we can directly output a volumetric image format instead
//Very hackily strip off file suffix.
outname = filename.substr(0, filename.size()-4) + std::string(".vti");
std::cout << "Writing results to: " << outname << "\n";
vtkSmartPointer<vtkImageData> output_volume = vtkSmartPointer<vtkImageData>::New();
output_volume->SetDimensions(phi_grid.ni ,phi_grid.nj ,phi_grid.nk);
output_volume->SetOrigin( phi_grid.ni*dx/2, phi_grid.nj*dx/2,phi_grid.nk*dx/2);
output_volume->SetSpacing(dx,dx,dx);
vtkSmartPointer<vtkFloatArray> distance = vtkSmartPointer<vtkFloatArray>::New();
distance->SetNumberOfTuples(phi_grid.a.size());
output_volume->GetPointData()->AddArray(distance);
distance->SetName("Distance");
for(unsigned int i = 0; i < phi_grid.a.size(); ++i) {
distance->SetValue(i, phi_grid.a[i]);
}
vtkSmartPointer<vtkXMLImageDataWriter> writer =
vtkSmartPointer<vtkXMLImageDataWriter>::New();
writer->SetFileName(outname.c_str());
#if VTK_MAJOR_VERSION <= 5
writer->SetInput(output_volume);
#else
writer->SetInputData(output_volume);
#endif
writer->Write();
#else
// if VTK support is missing, default back to the original ascii file-dump.
//Very hackily strip off file suffix.
outname = filename.substr(0, filename.size()-4) + std::string(".sdf");
std::cout << "Writing results to: " << outname << "\n";
std::ofstream outfile( outname.c_str());
outfile << phi_grid.ni << " " << phi_grid.nj << " " << phi_grid.nk << std::endl;
outfile << min_box[0] << " " << min_box[1] << " " << min_box[2] << std::endl;
outfile << dx << std::endl;
for(unsigned int i = 0; i < phi_grid.a.size(); ++i) {
outfile << phi_grid.a[i] << std::endl;
}
outfile.close();
#endif
std::cout << "Processing complete.\n";
return 0;
}
================================================
FILE: Externals/SDFGen/makelevelset3.cpp
================================================
#include "makelevelset3.h"
// find distance x0 is from segment x1-x2
static float point_segment_distance(const Vec3f &x0, const Vec3f &x1, const Vec3f &x2)
{
Vec3f dx(x2-x1);
double m2=mag2(dx);
// find parameter value of closest point on segment
float s12=(float)(dot(x2-x0, dx)/m2);
if(s12<0){
s12=0;
}else if(s12>1){
s12=1;
}
// and find the distance
return dist(x0, s12*x1+(1-s12)*x2);
}
// find distance x0 is from triangle x1-x2-x3
static float point_triangle_distance(const Vec3f &x0, const Vec3f &x1, const Vec3f &x2, const Vec3f &x3)
{
// first find barycentric coordinates of closest point on infinite plane
Vec3f x13(x1-x3), x23(x2-x3), x03(x0-x3);
float m13=mag2(x13), m23=mag2(x23), d=dot(x13,x23);
float invdet=1.f/max(m13*m23-d*d,1e-30f);
float a=dot(x13,x03), b=dot(x23,x03);
// the barycentric coordinates themselves
float w23=invdet*(m23*a-d*b);
float w31=invdet*(m13*b-d*a);
float w12=1-w23-w31;
if(w23>=0 && w31>=0 && w12>=0){ // if we're inside the triangle
return dist(x0, w23*x1+w31*x2+w12*x3);
}else{ // we have to clamp to one of the edges
if(w23>0) // this rules out edge 2-3 for us
return min(point_segment_distance(x0,x1,x2), point_segment_distance(x0,x1,x3));
else if(w31>0) // this rules out edge 1-3
return min(point_segment_distance(x0,x1,x2), point_segment_distance(x0,x2,x3));
else // w12 must be >0, ruling out edge 1-2
return min(point_segment_distance(x0,x1,x3), point_segment_distance(x0,x2,x3));
}
}
static void check_neighbour(const std::vector<Vec3ui> &tri, const std::vector<Vec3f> &x,
Array3f &phi, Array3i &closest_tri,
const Vec3f &gx, int i0, int j0, int k0, int i1, int j1, int k1)
{
if(closest_tri(i1,j1,k1)>=0){
unsigned int p, q, r; assign(tri[closest_tri(i1,j1,k1)], p, q, r);
float d=point_triangle_distance(gx, x[p], x[q], x[r]);
if(d<phi(i0,j0,k0)){
phi(i0,j0,k0)=d;
closest_tri(i0,j0,k0)=closest_tri(i1,j1,k1);
}
}
}
static void sweep(const std::vector<Vec3ui> &tri, const std::vector<Vec3f> &x,
Array3f &phi, Array3i &closest_tri, const Vec3f &origin, float dx,
int di, int dj, int dk)
{
int i0, i1;
if(di>0){ i0=1; i1=phi.ni; }
else{ i0=phi.ni-2; i1=-1; }
int j0, j1;
if(dj>0){ j0=1; j1=phi.nj; }
else{ j0=phi.nj-2; j1=-1; }
int k0, k1;
if(dk>0){ k0=1; k1=phi.nk; }
else{ k0=phi.nk-2; k1=-1; }
for(int k=k0; k!=k1; k+=dk) for(int j=j0; j!=j1; j+=dj) for(int i=i0; i!=i1; i+=di){
Vec3f gx(i*dx+origin[0], j*dx+origin[1], k*dx+origin[2]);
check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i-di, j, k);
check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i, j-dj, k);
check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i-di, j-dj, k);
check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i, j, k-dk);
check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i-di, j, k-dk);
check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i, j-dj, k-dk);
check_neighbour(tri, x, phi, closest_tri, gx, i, j, k, i-di, j-dj, k-dk);
}
}
// calculate twice signed area of triangle (0,0)-(x1,y1)-(x2,y2)
// return an SOS-determined sign (-1, +1, or 0 only if it's a truly degenerate triangle)
static int orientation(double x1, double y1, double x2, double y2, double &twice_signed_area)
{
twice_signed_area=y1*x2-x1*y2;
if(twice_signed_area>0) return 1;
else if(twice_signed_area<0) return -1;
else if(y2>y1) return 1;
else if(y2<y1) return -1;
else if(x1>x2) return 1;
else if(x1<x2) return -1;
else return 0; // only true when x1==x2 and y1==y2
}
// robust test of (x0,y0) in the triangle (x1,y1)-(x2,y2)-(x3,y3)
// if true is returned, the barycentric coordinates are set in a,b,c.
static bool point_in_triangle_2d(double x0, double y0,
double x1, double y1, double x2, double y2, double x3, double y3,
double& a, double& b, double& c)
{
x1-=x0; x2-=x0; x3-=x0;
y1-=y0; y2-=y0; y3-=y0;
int signa=orientation(x2, y2, x3, y3, a);
if(signa==0) return false;
int signb=orientation(x3, y3, x1, y1, b);
if(signb!=signa) return false;
int signc=orientation(x1, y1, x2, y2, c);
if(signc!=signa) return false;
double sum=a+b+c;
assert(sum!=0); // if the SOS signs match and are nonkero, there's no way all of a, b, and c are zero.
a/=sum;
b/=sum;
c/=sum;
return true;
}
void make_level_set3(const std::vector<Vec3ui> &tri, const std::vector<Vec3f> &x,
const Vec3f &origin, float dx, int ni, int nj, int nk,
Array3f &phi, const int exact_band)
{
phi.resize(ni, nj, nk);
phi.assign((ni+nj+nk)*dx); // upper bound on distance
Array3i closest_tri(ni, nj, nk, -1);
Array3i intersection_count(ni, nj, nk, 0); // intersection_count(i,j,k) is # of tri intersections in (i-1,i]x{j}x{k}
// we begin by initializing distances near the mesh, and figuring out intersection counts
Vec3f ijkmin, ijkmax;
for(unsigned int t=0; t<tri.size(); ++t){
unsigned int p, q, r; assign(tri[t], p, q, r);
// coordinates in grid to high precision
double fip=((double)x[p][0]-origin[0])/dx, fjp=((double)x[p][1]-origin[1])/dx, fkp=((double)x[p][2]-origin[2])/dx;
double fiq=((double)x[q][0]-origin[0])/dx, fjq=((double)x[q][1]-origin[1])/dx, fkq=((double)x[q][2]-origin[2])/dx;
double fir=((double)x[r][0]-origin[0])/dx, fjr=((double)x[r][1]-origin[1])/dx, fkr=((double)x[r][2]-origin[2])/dx;
// do distances nearby
int i0=clamp(int(min(fip,fiq,fir))-exact_band, 0, ni-1), i1=clamp(int(max(fip,fiq,fir))+exact_band+1, 0, ni-1);
int j0=clamp(int(min(fjp,fjq,fjr))-exact_band, 0, nj-1), j1=clamp(int(max(fjp,fjq,fjr))+exact_band+1, 0, nj-1);
int k0=clamp(int(min(fkp,fkq,fkr))-exact_band, 0, nk-1), k1=clamp(int(max(fkp,fkq,fkr))+exact_band+1, 0, nk-1);
for(int k=k0; k<=k1; ++k) for(int j=j0; j<=j1; ++j) for(int i=i0; i<=i1; ++i){
Vec3f gx(i*dx+origin[0], j*dx+origin[1], k*dx+origin[2]);
float d=point_triangle_distance(gx, x[p], x[q], x[r]);
if(d<phi(i,j,k)){
phi(i,j,k)=d;
closest_tri(i,j,k)=t;
}
}
// and do intersection counts
j0=clamp((int)std::ceil(min(fjp,fjq,fjr)), 0, nj-1);
j1=clamp((int)std::floor(max(fjp,fjq,fjr)), 0, nj-1);
k0=clamp((int)std::ceil(min(fkp,fkq,fkr)), 0, nk-1);
k1=clamp((int)std::floor(max(fkp,fkq,fkr)), 0, nk-1);
for(int k=k0; k<=k1; ++k) for(int j=j0; j<=j1; ++j){
double a, b, c;
if(point_in_triangle_2d(j, k, fjp, fkp, fjq, fkq, fjr, fkr, a, b, c)){
double fi=a*fip+b*fiq+c*fir; // intersection i coordinate
int i_interval=int(std::ceil(fi)); // intersection is in (i_interval-1,i_interval]
if(i_interval<0) ++intersection_count(0, j, k); // we enlarge the first interval to include everything to the -x direction
else if(i_interval<ni) ++intersection_count(i_interval,j,k);
// we ignore intersections that are beyond the +x side of the grid
}
}
}
// and now we fill in the rest of the distances with fast sweeping
for(unsigned int pass=0; pass<2; ++pass){
sweep(tri, x, phi, closest_tri, origin, dx, +1, +1, +1);
sweep(tri, x, phi, closest_tri, origin, dx, -1, -1, -1);
sweep(tri, x, phi, closest_tri, origin, dx, +1, +1, -1);
sweep(tri, x, phi, closest_tri, origin, dx, -1, -1, +1);
sweep(tri, x, phi, closest_tri, origin, dx, +1, -1, +1);
sweep(tri, x, phi, closest_tri, origin, dx, -1, +1, -1);
sweep(tri, x, phi, closest_tri, origin, dx, +1, -1, -1);
sweep(tri, x, phi, closest_tri, origin, dx, -1, +1, +1);
}
// then figure out signs (inside/outside) from intersection counts
for(int k=0; k<nk; ++k) for(int j=0; j<nj; ++j){
int total_count=0;
for(int i=0; i<ni; ++i){
total_count+=intersection_count(i,j,k);
if(total_count%2==1){ // if parity of intersections so far is odd,
phi(i,j,k)=-phi(i,j,k); // we are inside the mesh
}
}
}
}
================================================
FILE: Externals/SDFGen/makelevelset3.h
================================================
#ifndef MAKELEVELSET3_H
#define MAKELEVELSET3_H
#include "array3.h"
#include "vec.h"
// tri is a list of triangles in the mesh, and x is the positions of the vertices
// absolute distances will be nearly correct for triangle soup, but a closed mesh is
// needed for accurate signs. Distances for all grid cells within exact_band cells of
// a triangle should be exact; further away a distance is calculated but it might not
// be to the closest triangle - just one nearby.
void make_level_set3(const std::vector<Vec3ui> &tri, const std::vector<Vec3f> &x,
const Vec3f &origin, float dx, int nx, int ny, int nz,
Array3f &phi, const int exact_band=1);
#endif
================================================
FILE: Externals/SDFGen/util.h
================================================
#ifndef UTIL_H
#define UTIL_H
#include <algorithm>
#include <vector>
#include <cmath>
#include <iostream>
#ifndef M_PI
const double M_PI = 3.1415926535897932384626433832795;
#endif
#ifdef WIN32
#undef min
#undef max
#endif
using std::min;
using std::max;
using std::swap;
template<class T>
inline T sqr(const T& x)
{ return x*x; }
template<class T>
inline T cube(const T& x)
{ return x*x*x; }
template<class T>
inline T min(T a1, T a2, T a3)
{ return min(a1, min(a2, a3)); }
template<class T>
inline T min(T a1, T a2, T a3, T a4)
{ return min(min(a1, a2), min(a3, a4)); }
template<class T>
inline T min(T a1, T a2, T a3, T a4, T a5)
{ return min(min(a1, a2), min(a3, a4), a5); }
template<class T>
inline T min(T a1, T a2, T a3, T a4, T a5, T a6)
{ return min(min(a1, a2), min(a3, a4), min(a5, a6)); }
template<class T>
inline T max(T a1, T a2, T a3)
{ return max(a1, max(a2, a3)); }
template<class T>
inline T max(T a1, T a2, T a3, T a4)
{ return max(max(a1, a2), max(a3, a4)); }
template<class T>
inline T max(T a1, T a2, T a3, T a4, T a5)
{ return max(max(a1, a2), max(a3, a4), a5); }
template<class T>
inline T max(T a1, T a2, T a3, T a4, T a5, T a6)
{ return max(max(a1, a2), max(a3, a4), max(a5, a6)); }
template<class T>
inline void minmax(T a1, T a2, T& amin, T& amax)
{
if(a1<a2){
amin=a1;
amax=a2;
}else{
amin=a2;
amax=a1;
}
}
template<class T>
inline void minmax(T a1, T a2, T a3, T& amin, T& amax)
{
if(a1<a2){
if(a1<a3){
amin=a1;
if(a2<a3) amax=a3;
else amax=a2;
}else{
amin=a3;
if(a1<a2) amax=a2;
else amax=a1;
}
}else{
if(a2<a3){
amin=a2;
if(a1<a3) amax=a3;
else amax=a1;
}else{
amin=a3;
amax=a1;
}
}
}
template<class T>
inline void minmax(T a1, T a2, T a3, T a4, T& amin, T& amax)
{
if(a1<a2){
if(a3<a4){
amin=min(a1,a3);
amax=max(a2,a4);
}else{
amin=min(a1,a4);
amax=max(a2,a3);
}
}else{
if(a3<a4){
amin=min(a2,a3);
amax=max(a1,a4);
}else{
amin=min(a2,a4);
amax=max(a1,a3);
}
}
}
template<class T>
inline void minmax(T a1, T a2, T a3, T a4, T a5, T& amin, T& amax)
{
//@@@ the logic could be shortcircuited a lot!
amin=min(a1,a2,a3,a4,a5);
amax=max(a1,a2,a3,a4,a5);
}
template<class T>
inline void minmax(T a1, T a2, T a3, T a4, T a5, T a6, T& amin, T& amax)
{
//@@@ the logic could be shortcircuited a lot!
amin=min(a1,a2,a3,a4,a5,a6);
amax=max(a1,a2,a3,a4,a5,a6);
}
template<class T>
inline void update_minmax(T a1, T& amin, T& amax)
{
if(a1<amin) amin=a1;
else if(a1>amax) amax=a1;
}
template<class T>
inline void sort(T &a, T &b, T &c)
{
T temp;
if(a<b){
if(a<c){
if(c<b){ // a<c<b
temp=c;c=b;b=temp;
} // else: a<b<c
}else{ // c<a<b
temp=c;c=b;b=a;a=temp;
}
}else{
if(b<c){
if(a<c){ //b<a<c
temp=b;b=a;a=temp;
}else{ // b<c<a
temp=b;b=c;c=a;a=temp;
}
}else{ // c<b<a
temp=c;c=a;a=temp;
}
}
}
template<class T>
inline T clamp(T a, T lower, T upper)
{
if(a<lower) return lower;
else if(a>upper) return upper;
else return a;
}
// only makes sense with T=float or double
template<class T>
inline T smooth_step(T r)
{
if(r<0) return 0;
else if(r>1) return 1;
return r*r*r*(10+r*(-15+r*6));
}
// only makes sense with T=float or double
template<class T>
inline T smooth_step(T r, T r_lower, T r_upper, T value_lower, T value_upper)
{ return value_lower + smooth_step((r-r_lower)/(r_upper-r_lower)) * (value_upper-value_lower); }
// only makes sense with T=float or double
template<class T>
inline T ramp(T r)
{ return smooth_step((r+1)/2)*2-1; }
#ifdef WIN32
inline int lround(double x)
{
if(x>0)
return (x-floor(x)<0.5) ? (int)floor(x) : (int)ceil(x);
else
return (x-floor(x)<=0.5) ? (int)floor(x) : (int)ceil(x);
}
inline double remainder(double x, double y)
{
return x-std::floor(x/y+0.5)*y;
}
#endif
inline unsigned int round_up_to_power_of_two(unsigned int n)
{
int exponent=0;
--n;
while(n){
++exponent;
n>>=1;
}
return 1<<exponent;
}
inline unsigned int round_down_to_power_of_two(unsigned int n)
{
int exponent=0;
while(n>1){
++exponent;
n>>=1;
}
return 1<<exponent;
}
// Transforms even the sequence 0,1,2,3,... into reasonably good random numbers
// Challenge: improve on this in speed and "randomness"!
// This seems to pass several statistical tests, and is a bijective map (of 32-bit unsigned ints)
inline unsigned int randhash(unsigned int seed)
{
unsigned int i=(seed^0xA3C59AC3u)*2654435769u;
i^=(i>>16);
i*=2654435769u;
i^=(i>>16);
i*=2654435769u;
return i;
}
// the inverse of randhash
inline unsigned int unhash(unsigned int h)
{
h*=340573321u;
h^=(h>>16);
h*=340573321u;
h^=(h>>16);
h*=340573321u;
h^=0xA3C59AC3u;
return h;
}
// returns repeatable stateless pseudo-random number in [0,1]
inline double randhashd(unsigned int seed)
{ return randhash(seed)/(double)UINT_MAX; }
inline float randhashf(unsigned int seed)
{ return randhash(seed)/(float)UINT_MAX; }
// returns repeatable stateless pseudo-random number in [a,b]
inline double randhashd(unsigned int seed, double a, double b)
{ return (b-a)*randhash(seed)/(double)UINT_MAX + a; }
inline float randhashf(unsigned int seed, float a, float b)
{ return ( (b-a)*randhash(seed)/(float)UINT_MAX + a); }
inline int intlog2(int x)
{
int exp=-1;
while(x){
x>>=1;
++exp;
}
return exp;
}
template<class T>
inline void get_barycentric(T x, int& i, T& f, int i_low, int i_high)
{
T s=std::floor(x);
i=(int)s;
if(i<i_low){
i=i_low;
f=0;
}else if(i>i_high-2){
i=i_high-2;
f=1;
}else
f=(T)(x-s);
}
template<class S, class T>
inline S lerp(const S& value0, const S& value1, T f)
{ return (1-f)*value0 + f*value1; }
template<class S, class T>
inline S bilerp(const S& v00, const S& v10,
const S& v01, const S& v11,
T fx, T fy)
{
return lerp(lerp(v00, v10, fx),
lerp(v01, v11, fx),
fy);
}
template<class S, class T>
inline S trilerp(const S& v000, const S& v100,
const S& v010, const S& v110,
const S& v001, const S& v101,
const S& v011, const S& v111,
T fx, T fy, T fz)
{
return lerp(bilerp(v000, v100, v010, v110, fx, fy),
bilerp(v001, v101, v011, v111, fx, fy),
fz);
}
template<class S, class T>
inline S quadlerp(const S& v0000, const S& v1000,
const S& v0100, const S& v1100,
const S& v0010, const S& v1010,
const S& v0110, const S& v1110,
const S& v0001, const S& v1001,
const S& v0101, const S& v1101,
const S& v0011, const S& v1011,
const S& v0111, const S& v1111,
T fx, T fy, T fz, T ft)
{
return lerp(trilerp(v0000, v1000, v0100, v1100, v0010, v1010, v0110, v1110, fx, fy, fz),
trilerp(v0001, v1001, v0101, v1101, v0011, v1011, v0111, v1111, fx, fy, fz),
ft);
}
// f should be between 0 and 1, with f=0.5 corresponding to balanced weighting between w0 and w2
template<class T>
inline void quadratic_bspline_weights(T f, T& w0, T& w1, T& w2)
{
w0=T(0.5)*sqr(f-1);
w1=T(0.75)-sqr(f-T(0.5));;
w2=T(0.5)*sqr(f);
}
// f should be between 0 and 1
template<class T>
inline void cubic_interp_weights(T f, T& wneg1, T& w0, T& w1, T& w2)
{
T f2(f*f), f3(f2*f);
wneg1=-T(1./3)*f+T(1./2)*f2-T(1./6)*f3;
w0=1-f2+T(1./2)*(f3-f);
w1=f+T(1./2)*(f2-f3);
w2=T(1./6)*(f3-f);
}
template<class S, class T>
inline S cubic_interp(const S& value_neg1, const S& value0, const S& value1, const S& value2, T f)
{
T wneg1, w0, w1, w2;
cubic_interp_weights(f, wneg1, w0, w1, w2);
return wneg1*value_neg1 + w0*value0 + w1*value1 + w2*value2;
}
template<class T>
void zero(std::vector<T>& v)
{ for(int i=(int)v.size()-1; i>=0; --i) v[i]=0; }
template<class T>
T abs_max(const std::vector<T>& v)
{
T m=0;
for(int i=(int)v.size()-1; i>=0; --i){
if(std::fabs(v[i])>m)
m=std::fabs(v[i]);
}
return m;
}
template<class T>
bool contains(const std::vector<T>& a, T e)
{
for(unsigned int i=0; i<a.size(); ++i)
if(a[i]==e) return true;
return false;
}
template<class T>
void add_unique(std::vector<T>& a, T e)
{
for(unsigned int i=0; i<a.size(); ++i)
if(a[i]==e) return;
a.push_back(e);
}
template<class T>
void insert(std::vector<T>& a, unsigned int index, T e)
{
a.push_back(a.back());
for(unsigned int i=(unsigned int)a.size()-1; i>index; --i)
a[i]=a[i-1];
a[index]=e;
}
template<class T>
void erase(std::vector<T>& a, unsigned int index)
{
for(unsigned int i=index; i<a.size()-1; ++i)
a[i]=a[i+1];
a.pop_back();
}
template<class T>
void erase_swap(std::vector<T>& a, unsigned int index)
{
for(unsigned int i=index; i<a.size()-1; ++i)
swap(a[i], a[i+1]);
a.pop_back();
}
template<class T>
void erase_unordered(std::vector<T>& a, unsigned int index)
{
a[index]=a.back();
a.pop_back();
}
template<class T>
void erase_unordered_swap(std::vector<T>& a, unsigned int index)
{
swap(a[index], a.back());
a.pop_back();
}
template<class T>
void find_and_erase_unordered(std::vector<T>& a, const T& doomed_element)
{
for(unsigned int i=0; i<a.size(); ++i)
if(a[i]==doomed_element){
erase_unordered(a, i);
return;
}
}
template<class T>
void replace_once(std::vector<T>& a, const T& old_element, const T& new_element)
{
for(unsigned int i=0; i<a.size(); ++i)
if(a[i]==old_element){
a[i]=new_element;
return;
}
}
template<class T>
void write_matlab(std::ostream& output, const std::vector<T>& a, const char *variable_name, bool column_vector=true, int significant_digits=18)
{
output<<variable_name<<"=[";
std::streamsize old_precision=output.precision();
output.precision(significant_digits);
for(unsigned int i=0; i<a.size(); ++i){
output<<a[i]<<" ";
}
output<<"]";
if(column_vector)
output<<"'";
output<<";"<<std::endl;
output.precision(old_precision);
}
#endif
================================================
FILE: Externals/SDFGen/vec.h
================================================
#ifndef VEC_H
#define VEC_H
#include <cassert>
#include <cmath>
#include <iostream>
#include "util.h"
// Defines a thin wrapper around fixed size C-style arrays, using template parameters,
// which is useful for dealing with vectors of different dimensions.
// For example, float[3] is equivalent to Vec<3,float>.
// Entries in the vector are accessed with the overloaded [] operator, so
// for example if x is a Vec<3,float>, then the middle entry is x[1].
// For convenience, there are a number of typedefs for abbreviation:
// Vec<3,float> -> Vec3f
// Vec<2,int> -> Vec2i
// and so on.
// Arithmetic operators are appropriately overloaded, and functions are defined
// for additional operations (such as dot-products, norms, cross-products, etc.)
template<unsigned int N, class T>
struct Vec
{
T v[N];
Vec<N,T>(void)
{}
explicit Vec<N,T>(T value_for_all)
{ for(unsigned int i=0; i<N; ++i) v[i]=value_for_all; }
template<class S>
explicit Vec<N,T>(const S *source)
{ for(unsigned int i=0; i<N; ++i) v[i]=(T)source[i]; }
template <class S>
explicit Vec<N,T>(const Vec<N,S>& source)
{ for(unsigned int i=0; i<N; ++i) v[i]=(T)source[i]; }
Vec<N,T>(T v0, T v1)
{
assert(N==2);
v[0]=v0; v[1]=v1;
}
Vec<N,T>(T v0, T v1, T v2)
{
assert(N==3);
v[0]=v0; v[1]=v1; v[2]=v2;
}
Vec<N,T>(T v0, T v1, T v2, T v3)
{
assert(N==4);
v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3;
}
Vec<N,T>(T v0, T v1, T v2, T v3, T v4)
{
assert(N==5);
v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; v[4]=v4;
}
Vec<N,T>(T v0, T v1, T v2, T v3, T v4, T v5)
{
assert(N==6);
v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; v[4]=v4; v[5]=v5;
}
T &operator[](int index)
{
assert(0<=index && (unsigned int)index<N);
return v[index];
}
const T &operator[](int index) const
{
assert(0<=index && (unsigned int)index<N);
return v[index];
}
bool nonzero(void) const
{
for(unsigned int i=0; i<N; ++i) if(v[i]) return true;
return false;
}
Vec<N,T> operator+=(const Vec<N,T> &w)
{
for(unsigned int i=0; i<N; ++i) v[i]+=w[i];
return *this;
}
Vec<N,T> operator+(const Vec<N,T> &w) const
{
Vec<N,T> sum(*this);
sum+=w;
return sum;
}
Vec<N,T> operator-=(const Vec<N,T> &w)
{
for(unsigned int i=0; i<N; ++i) v[i]-=w[i];
return *this;
}
Vec<N,T> operator-(void) const // unary minus
{
Vec<N,T> negative;
for(unsigned int i=0; i<N; ++i) negative.v[i]=-v[i];
return negative;
}
Vec<N,T> operator-(const Vec<N,T> &w) const // (binary) subtraction
{
Vec<N,T> diff(*this);
diff-=w;
return diff;
}
Vec<N,T> operator*=(T a)
{
for(unsigned int i=0; i<N; ++i) v[i]*=a;
return *this;
}
Vec<N,T> operator*(T a) const
{
Vec<N,T> w(*this);
w*=a;
return w;
}
Vec<N,T> operator*=(const Vec<N,T> &w)
{
for(unsigned int i=0; i<N; ++i) v[i]*=w.v[i];
return *this;
}
Vec<N,T> operator*(const Vec<N,T> &w) const
{
Vec<N,T> componentwise_product;
for(unsigned int i=0; i<N; ++i) componentwise_product[i]=v[i]*w.v[i];
return componentwise_product;
}
Vec<N,T> operator/=(T a)
{
for(unsigned int i=0; i<N; ++i) v[i]/=a;
return *this;
}
Vec<N,T> operator/(T a) const
{
Vec<N,T> w(*this);
w/=a;
return w;
}
};
typedef Vec<2,double> Vec2d;
typedef Vec<2,float> Vec2f;
typedef Vec<2,int> Vec2i;
typedef Vec<2,unsigned int> Vec2ui;
typedef Vec<2,short> Vec2s;
typedef Vec<2,unsigned short> Vec2us;
typedef Vec<2,char> Vec2c;
typedef Vec<2,unsigned char> Vec2uc;
typedef Vec<3,double> Vec3d;
typedef Vec<3,float> Vec3f;
typedef Vec<3,int> Vec3i;
typedef Vec<3,unsigned int> Vec3ui;
typedef Vec<3,short> Vec3s;
typedef Vec<3,unsigned short> Vec3us;
typedef Vec<3,char> Vec3c;
typedef Vec<3,unsigned char> Vec3uc;
typedef Vec<4,double> Vec4d;
typedef Vec<4,float> Vec4f;
typedef Vec<4,int> Vec4i;
typedef Vec<4,unsigned int> Vec4ui;
typedef Vec<4,short> Vec4s;
typedef Vec<4,unsigned short> Vec4us;
typedef Vec<4,char> Vec4c;
typedef Vec<4,unsigned char> Vec4uc;
typedef Vec<6,double> Vec6d;
typedef Vec<6,float> Vec6f;
typedef Vec<6,unsigned int> Vec6ui;
typedef Vec<6,int> Vec6i;
typedef Vec<6,short> Vec6s;
typedef Vec<6,unsigned short> Vec6us;
typedef Vec<6,char> Vec6c;
typedef Vec<6,unsigned char> Vec6uc;
template<unsigned int N, class T>
T mag2(const Vec<N,T> &a)
{
T l=sqr(a.v[0]);
for(unsigned int i=1; i<N; ++i) l+=sqr(a.v[i]);
return l;
}
template<unsigned int N, class T>
T mag(const Vec<N,T> &a)
{ return sqrt(mag2(a)); }
template<unsigned int N, class T>
inline T dist2(const Vec<N,T> &a, const Vec<N,T> &b)
{
T d=sqr(a.v[0]-b.v[0]);
for(unsigned int i=1; i<N; ++i) d+=sqr(a.v[i]-b.v[i]);
return d;
}
template<unsigned int N, class T>
inline T dist(const Vec<N,T> &a, const Vec<N,T> &b)
{ return std::sqrt(dist2(a,b)); }
template<unsigned int N, class T>
inline void normalize(Vec<N,T> &a)
{ a/=mag(a); }
template<unsigned int N, class T>
inline Vec<N,T> normalized(const Vec<N,T> &a)
{ return a/mag(a); }
template<unsigned int N, class T>
inline T infnorm(const Vec<N,T> &a)
{
T d=std::fabs(a.v[0]);
for(unsigned int i=1; i<N; ++i) d=max(std::fabs(a.v[i]),d);
return d;
}
template<unsigned int N, class T>
void zero(Vec<N,T> &a)
{
for(unsigned int i=0; i<N; ++i)
a.v[i] = 0;
}
template<unsigned int N, class T>
std::ostream &operator<<(std::ostream &out, const Vec<N,T> &v)
{
out<<v.v[0];
for(unsigned int i=1; i<N; ++i)
out<<' '<<v.v[i];
return out;
}
template<unsigned int N, class T>
std::istream &operator>>(std::istream &in, Vec<N,T> &v)
{
in>>v.v[0];
for(unsigned int i=1; i<N; ++i)
in>>v.v[i];
return in;
}
template<unsigned int N, class T>
inline bool operator==(const Vec<N,T> &a, const Vec<N,T> &b)
{
bool t = (a.v[0] == b.v[0]);
unsigned int i=1;
while(i<N && t) {
t = t && (a.v[i]==b.v[i]);
++i;
}
return t;
}
template<unsigned int N, class T>
inline bool operator!=(const Vec<N,T> &a, const Vec<N,T> &b)
{
bool t = (a.v[0] != b.v[0]);
unsigned int i=1;
while(i<N && !t) {
t = t || (a.v[i]!=b.v[i]);
++i;
}
return t;
}
template<unsigned int N, class T>
inline Vec<N,T> operator*(T a, const Vec<N,T> &v)
{
Vec<N,T> w(v);
w*=a;
return w;
}
template<unsigned int N, class T>
inline T min(const Vec<N,T> &a)
{
T m=a.v[0];
for(unsigned int i=1; i<N; ++i) if(a.v[i]<m) m=a.v[i];
return m;
}
template<unsigned int N, class T>
inline Vec<N,T> min_union(const Vec<N,T> &a, const Vec<N,T> &b)
{
Vec<N,T> m;
for(unsigned int i=0; i<N; ++i) (a.v[i] < b.v[i]) ? m.v[i]=a.v[i] : m.v[i]=b.v[i];
return m;
}
template<unsigned int N, class T>
inline Vec<N,T> max_union(const Vec<N,T> &a, const Vec<N,T> &b)
{
Vec<N,T> m;
for(unsigned int i=0; i<N; ++i) (a.v[i] > b.v[i]) ? m.v[i]=a.v[i] : m.v[i]=b.v[i];
return m;
}
template<unsigned int N, class T>
inline T max(const Vec<N,T> &a)
{
T m=a.v[0];
for(unsigned int i=1; i<N; ++i) if(a.v[i]>m) m=a.v[i];
return m;
}
template<unsigned int N, class T>
inline T dot(const Vec<N,T> &a, const Vec<N,T> &b)
{
T d=a.v[0]*b.v[0];
for(unsigned int i=1; i<N; ++i) d+=a.v[i]*b.v[i];
return d;
}
template<class T>
inline Vec<2,T> rotate(const Vec<2,T>& a, float angle)
{
T c = cos(angle);
T s = sin(angle);
return Vec<2,T>(c*a[0] - s*a[1],s*a[0] + c*a[1]); // counter-clockwise rotation
}
template<class T>
inline Vec<2,T> perp(const Vec<2,T> &a)
{ return Vec<2,T>(-a.v[1], a.v[0]); } // counter-clockwise rotation by 90 degrees
template<class T>
inline T cross(const Vec<2,T> &a, const Vec<2,T> &b)
{ return a.v[0]*b.v[1]-a.v[1]*b.v[0]; }
template<class T>
inline Vec<3,T> cross(const Vec<3,T> &a, const Vec<3,T> &b)
{ return Vec<3,T>(a.v[1]*b.v[2]-a.v[2]*b.v[1], a.v[2]*b.v[0]-a.v[0]*b.v[2], a.v[0]*b.v[1]-a.v[1]*b.v[0]); }
template<class T>
inline T triple(const Vec<3,T> &a, const Vec<3,T> &b, const Vec<3,T> &c)
{ return a.v[0]*(b.v[1]*c.v[2]-b.v[2]*c.v[1])
+a.v[1]*(b.v[2]*c.v[0]-b.v[0]*c.v[2])
+a.v[2]*(b.v[0]*c.v[1]-b.v[1]*c.v[0]); }
template<unsigned int N, class T>
inline unsigned int hash(const Vec<N,T> &a)
{
unsigned int h=a.v[0];
for(unsigned int i=1; i<N; ++i)
h=hash(h ^ a.v[i]);
return h;
}
template<unsigned int N, class T>
inline void assign(const Vec<N,T> &a, T &a0, T &a1)
{
assert(N==2);
a0=a.v[0]; a1=a.v[1];
}
template<unsigned int N, class T>
inline void assign(const Vec<N,T> &a, T &a0, T &a1, T &a2)
{
assert(N==3);
a0=a.v[0]; a1=a.v[1]; a2=a.v[2];
}
template<unsigned int N, class T>
inline void assign(const Vec<N,T> &a, T &a0, T &a1, T &a2, T &a3)
{
assert(N==4);
a0=a.v[0]; a1=a.v[1]; a2=a.v[2]; a3=a.v[3];
}
template<unsigned int N, class T>
inline void assign(const Vec<N,T> &a, T &a0, T &a1, T &a2, T &a3, T &a4, T &a5)
{
assert(N==6);
a0=a.v[0]; a1=a.v[1]; a2=a.v[2]; a3=a.v[3]; a4=a.v[4]; a5=a.v[5];
}
template<unsigned int N, class T>
inline Vec<N,int> round(const Vec<N,T> &a)
{
Vec<N,int> rounded;
for(unsigned int i=0; i<N; ++i)
rounded.v[i]=lround(a.v[i]);
return rounded;
}
template<unsigned int N, class T>
inline Vec<N,int> floor(const Vec<N,T> &a)
{
Vec<N,int> rounded;
for(unsigned int i=0; i<N; ++i)
rounded.v[i]=(int)floor(a.v[i]);
return rounded;
}
template<unsigned int N, class T>
inline Vec<N,int> ceil(const Vec<N,T> &a)
{
Vec<N,int> rounded;
for(unsigned int i=0; i<N; ++i)
rounded.v[i]=(int)ceil(a.v[i]);
return rounded;
}
template<unsigned int N, class T>
inline Vec<N,T> fabs(const Vec<N,T> &a)
{
Vec<N,T> result;
for(unsigned int i=0; i<N; ++i)
result.v[i]=fabs(a.v[i]);
return result;
}
template<unsigned int N, class T>
inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, Vec<N,T> &xmin, Vec<N,T> &xmax)
{
for(unsigned int i=0; i<N; ++i)
minmax(x0.v[i], x1.v[i], xmin.v[i], xmax.v[i]);
}
template<unsigned int N, class T>
inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, const Vec<N,T> &x2, Vec<N,T> &xmin, Vec<N,T> &xmax)
{
for(unsigned int i=0; i<N; ++i)
minmax(x0.v[i], x1.v[i], x2.v[i], xmin.v[i], xmax.v[i]);
}
template<unsigned int N, class T>
inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, const Vec<N,T> &x2, const Vec<N,T> &x3,
Vec<N,T> &xmin, Vec<N,T> &xmax)
{
for(unsigned int i=0; i<N; ++i)
minmax(x0.v[i], x1.v[i], x2.v[i], x3.v[i], xmin.v[i], xmax.v[i]);
}
template<unsigned int N, class T>
inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, const Vec<N,T> &x2, const Vec<N,T> &x3, const Vec<N,T> &x4,
Vec<N,T> &xmin, Vec<N,T> &xmax)
{
for(unsigned int i=0; i<N; ++i)
minmax(x0.v[i], x1.v[i], x2.v[i], x3.v[i], x4.v[i], xmin.v[i], xmax.v[i]);
}
template<unsigned int N, class T>
inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, const Vec<N,T> &x2, const Vec<N,T> &x3, const Vec<N,T> &x4,
const Vec<N,T> &x5, Vec<N,T> &xmin, Vec<N,T> &xmax)
{
for(unsigned int i=0; i<N; ++i)
minmax(x0.v[i], x1.v[i], x2.v[i], x3.v[i], x4.v[i], x5.v[i], xmin.v[i], xmax.v[i]);
}
template<unsigned int N, class T>
inline void update_minmax(const Vec<N,T> &x, Vec<N,T> &xmin, Vec<N,T> &xmax)
{
for(unsigned int i=0; i<N; ++i) update_minmax(x[i], xmin[i], xmax[i]);
}
#endif
================================================
FILE: Externals/function_ref/tl/function_ref.hpp
================================================
///
// function_ref - A low-overhead non-owning function
// Written in 2017 by Simon Brand (@TartanLlama)
//
// To the extent possible under law, the author(s) have dedicated all
// copyright and related and neighboring rights to this software to the
// public domain worldwide. This software is distributed without any warranty.
//
// You should have received a copy of the CC0 Public Domain Dedication
// along with this software. If not, see
// <http://creativecommons.org/publicdomain/zero/1.0/>.
///
#ifndef TL_FUNCTION_REF_HPP
#define TL_FUNCTION_REF_HPP
#define TL_FUNCTION_REF_VERSION_MAJOR 1
#define TL_FUNCTION_REF_VERSION_MINOR 0
#define TL_FUNCTION_REF_VERSION_PATCH 0
#if (defined(_MSC_VER) && _MSC_VER == 1900)
/// \exclude
#define TL_FUNCTION_REF_MSVC2015
#endif
#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \
!defined(__clang__))
/// \exclude
#define TL_FUNCTION_REF_GCC49
#endif
#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && \
!defined(__clang__))
/// \exclude
#define TL_FUNCTION_REF_GCC54
#endif
#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \
!defined(__clang__))
// GCC < 5 doesn't support overloading on const&& for member functions
/// \exclude
#define TL_FUNCTION_REF_NO_CONSTRR
#endif
#if __cplusplus > 201103L
/// \exclude
#define TL_FUNCTION_REF_CXX14
#endif
// constexpr implies const in C++11, not C++14
#if (__cplusplus == 201103L || defined(TL_FUNCTION_REF_MSVC2015) || \
defined(TL_FUNCTION_REF_GCC49)) && \
!defined(TL_FUNCTION_REF_GCC54)
/// \exclude
#define TL_FUNCTION_REF_11_CONSTEXPR
#else
/// \exclude
#define TL_FUNCTION_REF_11_CONSTEXPR constexpr
#endif
#include <functional>
#include <utility>
namespace tl {
namespace detail {
namespace fnref {
// C++14-style aliases for brevity
template <class T> using remove_const_t = typename std::remove_const<T>::type;
template <class T>
using remove_reference_t = typename std::remove_reference<T>::type;
template <class T> using decay_t = typename std::decay<T>::type;
template <bool E, class T = void>
using enable_if_t = typename std::enable_if<E, T>::type;
template <bool B, class T, class F>
using conditional_t = typename std::conditional<B, T, F>::type;
// std::invoke from C++17
// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
template <typename Fn, typename... Args,
typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>,
int = 0>
constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
-> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
return std::mem_fn(f)(std::forward<Args>(args)...);
}
template <typename Fn, typename... Args,
typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>{}>>
constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
-> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
return std::forward<Fn>(f)(std::forward<Args>(args)...);
}
// std::invoke_result from C++17
template <class F, class, class... Us> struct invoke_result_impl;
template <class F, class... Us>
struct invoke_result_impl<
F, decltype(tl::detail::fnref::invoke(std::declval<F>(), std::declval<Us>()...), void()),
Us...> {
using type = decltype(tl::detail::fnref::invoke(std::declval<F>(), std::declval<Us>()...));
};
template <class F, class... Us>
using invoke_result = invoke_result_impl<F, void, Us...>;
template <class F, class... Us>
using invoke_result_t = typename invoke_result<F, Us...>::type;
template <class, class R, class F, class... Args>
struct is_invocable_r_impl : std::false_type {};
template <class R, class F, class... Args>
struct is_invocable_r_impl<
typename std::is_convertible<invoke_result_t<F, Args...>, R>::type, R, F, Args...>
: std::true_type {};
template <class R, class F, class... Args>
using is_invocable_r = is_invocable_r_impl<std::true_type, R, F, Args...>;
} // namespace detail
} // namespace fnref
/// A lightweight non-owning reference to a callable.
///
/// Example usage:
///
/// ```cpp
/// void foo (function_ref<int(int)> func) {
/// std::cout << "Result is " << func(21); //42
/// }
///
/// foo([](int i) { return i*2; });
template <class F> class function_ref;
/// Specialization for function types.
template <class R, class... Args> class function_ref<R(Args...)> {
public:
constexpr function_ref() noexcept = delete;
/// Creates a `function_ref` which refers to the same callable as `rhs`.
constexpr function_ref(const function_ref<R(Args...)> &rhs) noexcept = default;
/// Constructs a `function_ref` referring to `f`.
///
/// \synopsis template <typename F> constexpr function_ref(F &&f) noexcept
template <typename F,
detail::fnref::enable_if_t<
!std::is_same<detail::fnref::decay_t<F>, function_ref>::value &&
detail::fnref::is_invocable_r<R, F &&, Args...>::value> * = nullptr>
TL_FUNCTION_REF_11_CONSTEXPR function_ref(F &&f) noexcept
: obj_(const_cast<void*>(reinterpret_cast<const void *>(std::addressof(f)))) {
callback_ = [](void *obj, Args... args) -> R {
return detail::fnref::invoke(
*reinterpret_cast<typename std::add_pointer<F>::type>(obj),
std::forward<Args>(args)...);
};
}
/// Makes `*this` refer to the same callable as `rhs`.
TL_FUNCTION_REF_11_CONSTEXPR function_ref<R(Args...)> &
operator=(const function_ref<R(Args...)> &rhs) noexcept = default;
/// Makes `*this` refer to `f`.
///
/// \synopsis template <typename F> constexpr function_ref &operator=(F &&f) noexcept;
template <typename F,
detail::fnref::enable_if_t<detail::fnref::is_invocable_r<R, F &&, Args...>::value>
* = nullptr>
TL_FUNCTION_REF_11_CONSTEXPR function_ref<R(Args...)> &operator=(F &&f) noexcept {
obj_ = reinterpret_cast<void *>(std::addressof(f));
callback_ = [](void *obj, Args... args) {
return detail::fnref::invoke(
*reinterpret_cast<typename std::add_pointer<F>::type>(obj),
std::forward<Args>(args)...);
};
return *this;
}
/// Swaps the referred callables of `*this` and `rhs`.
constexpr void swap(function_ref<R(Args...)> &rhs) noexcept {
std::swap(obj_, rhs.obj_);
std::swap(callback_, rhs.callback_);
}
/// Call the stored callable with the given arguments.
R operator()(Args... args) const {
return callback_(obj_, std::forward<Args>(args)...);
}
private:
void *obj_ = nullptr;
R (*callback_)(void *, Args...) = nullptr;
};
/// Swaps the referred callables of `lhs` and `rhs`.
template <typename R, typename... Args>
constexpr void swap(function_ref<R(Args...)> &lhs,
function_ref<R(Args...)> &rhs) noexcept {
lhs.swap(rhs);
}
#if __cplusplus >= 201703L
template <typename R, typename... Args>
function_ref(R (*)(Args...))->function_ref<R(Args...)>;
// TODO, will require some kind of callable traits
// template <typename F>
// function_ref(F) -> function_ref</* deduced if possible */>;
#endif
} // namespace tl
#endif
================================================
FILE: Externals/optional/tl/optional.hpp
================================================
///
// optional - An implementation of std::optional with extensions
// Written in 2017 by Simon Brand (simonrbrand@gmail.com, @TartanLlama)
//
// Documentation available at https://tl.tartanllama.xyz/
//
// To the extent possible under law, the author(s) have dedicated all
// copyright and related and neighboring rights to this software to the
// public domain worldwide. This software is distributed without any warranty.
//
// You should have received a copy of the CC0 Public Domain Dedication
// along with this software. If not, see
// <http://creativecommons.org/publicdomain/zero/1.0/>.
///
#ifndef TL_OPTIONAL_HPP
#define TL_OPTIONAL_HPP
#define TL_OPTIONAL_VERSION_MAJOR 1
#define TL_OPTIONAL_VERSION_MINOR 0
#define TL_OPTIONAL_VERSION_PATCH 0
#include <exception>
#include <functional>
#include <new>
#include <type_traits>
#include <utility>
#if (defined(_MSC_VER) && _MSC_VER == 1900)
#define TL_OPTIONAL_MSVC2015
#endif
#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \
!defined(__clang__))
#define TL_OPTIONAL_GCC49
#endif
#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && \
!defined(__clang__))
#define TL_OPTIONAL_GCC54
#endif
#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && \
!defined(__clang__))
#define TL_OPTIONAL_GCC55
#endif
#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \
!defined(__clang__))
// GCC < 5 doesn't support overloading on const&& for member functions
#define TL_OPTIONAL_NO_CONSTRR
// GCC < 5 doesn't support some standard C++11 type traits
#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
std::has_trivial_copy_constructor<T>::value
#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
// This one will be different for GCC 5.7 if it's ever supported
#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
// GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks std::vector
// for non-copyable types
#elif (defined(__GNUC__) && __GNUC__ < 8 && \
!defined(__clang__))
#ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
#define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
namespace tl {
namespace detail {
template<class T>
struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T>{};
#ifdef _GLIBCXX_VECTOR
template<class T, class A>
struct is_trivially_copy_constructible<std::vector<T,A>>
: std::is_trivially_copy_constructible<T>{};
#endif
}
}
#endif
#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
tl::detail::is_trivially_copy_constructible<T>::value
#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
std::is_trivially_copy_assignable<T>::value
#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
#else
#define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
std::is_trivially_copy_constructible<T>::value
#define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
std::is_trivially_copy_assignable<T>::value
#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
#endif
#if __cplusplus > 201103L
#define TL_OPTIONAL_CXX14
#endif
// constexpr implies const in C++11, not C++14
#if (__cplusplus == 201103L || defined(TL_OPTIONAL_MSVC2015) || \
defined(TL_OPTIONAL_GCC49))
#define TL_OPTIONAL_11_CONSTEXPR
#else
#define TL_OPTIONAL_11_CONSTEXPR constexpr
#endif
namespace tl {
#ifndef TL_MONOSTATE_INPLACE_MUTEX
#define TL_MONOSTATE_INPLACE_MUTEX
/// Used to represent an optional with no data; essentially a bool
class monostate {};
/// A tag type to tell optional to construct its value in-place
struct in_place_t {
explicit in_place_t() = default;
};
/// A tag to tell optional to construct its value in-place
static constexpr in_place_t in_place{};
#endif
template <class T> class optional;
namespace detail {
#ifndef TL_TRAITS_MUTEX
#define TL_TRAITS_MUTEX
// C++14-style aliases for brevity
template <class T> using remove_const_t = typename std::remove_const<T>::type;
template <class T>
using remove_reference_t = typename std::remove_reference<T>::type;
template <class T> using decay_t = typename std::decay<T>::type;
template <bool E, class T = void>
using enable_if_t = typename std::enable_if<E, T>::type;
template <bool B, class T, class F>
using conditional_t = typename std::conditional<B, T, F>::type;
// std::conjunction from C++17
template <class...> struct conjunction : std::true_type {};
template <class B> struct conjunction<B> : B {};
template <class B, class... Bs>
struct conjunction<B, Bs...>
: std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
#define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
#endif
// In C++11 mode, there's an issue in libc++'s std::mem_fn
// which results in a hard-error when using it in a noexcept expression
// in some cases. This is a check to workaround the common failing case.
#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
template <class T> struct is_pointer_to_non_const_member_func : std::false_type{};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)> : std::true_type{};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&> : std::true_type{};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&&> : std::true_type{};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile> : std::true_type{};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&> : std::true_type{};
template <class T, class Ret, class... Args>
struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&&> : std::true_type{};
template <class T> struct is_const_or_const_ref : std::false_type{};
template <class T> struct is_const_or_const_ref<T const&> : std::true_type{};
template <class T> struct is_const_or_const_ref<T const> : std::true_type{};
#endif
// std::invoke from C++17
// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
template <typename Fn, typename... Args,
#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value
&& is_const_or_const_ref<Args...>::value)>,
#endif
typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>,
int = 0>
constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
-> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
return std::mem_fn(f)(std::forward<Args>(args)...);
}
template <typename Fn, typename... Args,
typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
-> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
return std::forward<Fn>(f)(std::forward<Args>(args)...);
}
// std::invoke_result from C++17
template <class F, class, class... Us> struct invoke_result_impl;
template <class F, class... Us>
struct invoke_result_impl<
F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
Us...> {
using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
};
template <class F, class... Us>
using invoke_result = invoke_result_impl<F, void, Us...>;
template <class F, class... Us>
using invoke_result_t = typename invoke_result<F, Us...>::type;
#if defined(_MSC_VER) && _MSC_VER <= 1900
// TODO make a version which works with MSVC 2015
template <class T, class U = T> struct is_swappable : std::true_type {};
template <class T, class U = T> struct is_nothrow_swappable : std::true_type {};
#else
// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
namespace swap_adl_tests {
// if swap ADL finds this then it would call std::swap otherwise (same
// signature)
struct tag {};
template <class T> tag swap(T &, T &);
template <class T, std::size_t N> tag swap(T (&a)[N], T (&b)[N]);
// helper functions to test if an unqualified swap is possible, and if it
// becomes std::swap
template <class, class> std::false_type can_swap(...) noexcept(false);
template <class T, class U,
class = decltype(swap(std::declval<T &>(), std::declval<U &>()))>
std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(),
std::declval<U &>())));
template <class, class> std::false_type uses_std(...);
template <class T, class U>
std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag>
uses_std(int);
template <class T>
struct is_std_swap_noexcept
: std::integral_constant<bool,
std::is_nothrow_move_constructible<T>::value &&
std::is_nothrow_move_assignable<T>::value> {};
template <class T, std::size_t N>
struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
template <class T, class U>
struct is_adl_swap_noexcept
: std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
} // namespace swap_adl_tests
template <class T, class U = T>
struct is_swappable
: std::integral_constant<
bool,
decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value &&
(!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value ||
(std::is_move_assignable<T>::value &&
std::is_move_constructible<T>::value))> {};
template <class T, std::size_t N>
struct is_swappable<T[N], T[N]>
: std::integral_constant<
bool,
decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value &&
(!decltype(
detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value ||
is_swappable<T, T>::value)> {};
template <class T, class U = T>
struct is_nothrow_swappable
: std::integral_constant<
bool,
is_swappable<T, U>::value &&
((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
&&detail::swap_adl_tests::is_std_swap_noexcept<T>::value) ||
(!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
detail::swap_adl_tests::is_adl_swap_noexcept<T,
U>::value))> {
};
#endif
#endif
// std::void_t from C++17
template <class...> struct voider { using type = void; };
template <class... Ts> using void_t = typename voider<Ts...>::type;
// Trait for checking if a type is a tl::optional
template <class T> struct is_optional_impl : std::false_type {};
template <class T> struct is_optional_impl<optional<T>> : std::true_type {};
template <class T> using is_optional = is_optional_impl<decay_t<T>>;
// Change void to tl::monostate
template <class U>
using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
template <class F, class U, class = invoke_result_t<F, U>>
using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
// Check if invoking F for some Us returns void
template <class F, class = void, class... U> struct returns_void_impl;
template <class F, class... U>
struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...>
: std::is_void<invoke_result_t<F, U...>> {};
template <class F, class... U>
using returns_void = returns_void_impl<F, void, U...>;
template <class T, class... U>
using enable_if_ret_void = enable_if_t<returns_void<T &&, U...>::value>;
template <class T, class... U>
using disable_if_ret_void = enable_if_t<!returns_void<T &&, U...>::value>;
template <class T, class U>
using enable_forward_value =
detail::enable_if_t<std::is_constructible<T, U &&>::value &&
!std::is_same<detail::decay_t<U>, in_place_t>::value &&
!std::is_same<optional<T>, detail::decay_t<U>>::value>;
template <class T, class U, class Other>
using enable_from_other = detail::enable_if_t<
std::is_constructible<T, Other>::value &&
!std::is_constructible<T, optional<U> &>::value &&
!std::is_constructible<T, optional<U> &&>::value &&
!std::is_constructible<T, const optional<U> &>::value &&
!std::is_constructible<T, const optional<U> &&>::value &&
!std::is_convertible<optional<U> &, T>::value &&
!std::is_convertible<optional<U> &&, T>::value &&
!std::is_convertible<const optional<U> &, T>::value &&
!std::is_convertible<const optional<U> &&, T>::value>;
template <class T, class U>
using enable_assign_forward = detail::enable_if_t<
!std::is_same<optional<T>, detail::decay_t<U>>::value &&
!detail::conjunction<std::is_scalar<T>,
std::is_same<T, detail::decay_t<U>>>::value &&
std::is_constructible<T, U>::value && std::is_assignable<T &, U>::value>;
template <class T, class U, class Other>
using enable_assign_from_other = detail::enable_if_t<
std::is_constructible<T, Other>::value &&
std::is_assignable<T &, Other>::value &&
!std::is_constructible<T, optional<U> &>::value &&
!std::is_constructible<T, optional<U> &&>::value &&
!std::is_constructible<T, const optional<U> &>::value &&
!std::is_constructible<T, const optional<U> &&>::value &&
!std::is_convertible<optional<U> &, T>::value &&
!std::is_convertible<optional<U> &&, T>::value &&
!std::is_convertible<const optional<U> &, T>::value &&
!std::is_convertible<const optional<U> &&, T>::value &&
!std::is_assignable<T &, optional<U> &>::value &&
!std::is_assignable<T &, optional<U> &&>::value &&
!std::is_assignable<T &, const optional<U> &>::value &&
!std::is_assignable<T &, const optional<U> &&>::value>;
// The storage base manages the actual storage, and correctly propagates
// trivial destruction from T. This case is for when T is not trivially
// destructible.
template <class T, bool = ::std::is_trivially_destructible<T>::value>
struct optional_storage_base {
TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
: m_dummy(), m_has_value(false) {}
template <class... U>
TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
: m_value(std::forward<U>(u)...), m_has_value(true) {}
~optional_storage_base() {
if (m_has_value) {
m_value.~T();
m_has_value = false;
}
}
struct dummy {};
union {
dummy m_dummy;
T m_value;
};
bool m_has_value;
};
// This case is for when T is trivially destructible.
template <class T> struct optional_storage_base<T, true> {
TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept
: m_dummy(), m_has_value(false) {}
template <class... U>
TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
: m_value(std::forward<U>(u)...), m_has_value(true) {}
// No destructor, so this class is trivially destructible
struct dummy {};
union {
dummy m_dummy;
T m_value;
};
bool m_has_value = false;
};
// This base class provides some handy member functions which can be used in
// further derived classes
template <class T> struct optional_operations_base : optional_storage_base<T> {
using optional_storage_base<T>::optional_storage_base;
void hard_reset() noexcept {
get().~T();
this->m_has_value = false;
}
template <class... Args> void construct(Args &&... args) noexcept {
new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
this->m_has_value = true;
}
template <class Opt> void assign(Opt &&rhs) {
if (this->has_value()) {
if (rhs.has_value()) {
this->m_value = std::forward<Opt>(rhs).get();
} else {
this->m_value.~T();
this->m_has_value = false;
}
}
else if (rhs.has_value()) {
construct(std::forward<Opt>(rhs).get());
}
}
bool has_value() const { return this->m_has_value; }
TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_value; }
TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_value); }
#ifndef TL_OPTIONAL_NO_CONSTRR
constexpr const T &&get() const && { return std::move(this->m_value); }
#endif
};
// This class manages conditionally having a trivial copy constructor
// This specialization is for when T is trivially copy constructible
template <class T, bool = TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
struct optional_copy_base : optional_operations_base<T> {
using optional_operations_base<T>::optional_operations_base;
};
// This specialization is for when T is not trivially copy constructible
template <class T>
struct optional_copy_base<T, false> : optional_operations_base<T> {
using optional_operations_base<T>::optional_operations_base;
optional_copy_base() = default;
optional_copy_base(const optional_copy_base &rhs) {
if (rhs.has_value()) {
this->construct(rhs.get());
} else {
this->m_has_value = false;
}
}
optional_copy_base(optional_copy_base &&rhs) = default;
optional_copy_base &operator=(const optional_copy_base &rhs) = default;
optional_copy_base &operator=(optional_copy_base &&rhs) = default;
};
// This class manages conditionally having a trivial move constructor
// Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it
// doesn't implement an analogue to std::is_trivially_move_constructible. We
// have to make do with a non-trivial move constructor even if T is trivially
// move constructible
#ifndef TL_OPTIONAL_GCC49
template <class T, bool = std::is_trivially_move_constructible<T>::value>
struct optional_move_base : optional_copy_base<T> {
using optional_copy_base<T>::optional_copy_base;
};
#else
template <class T, bool = false> struct optional_move_base;
#endif
template <class T> struct optional_move_base<T, false> : optional_copy_base<T> {
using optional_copy_base<T>::optional_copy_base;
optional_move_base() = default;
optional_move_base(const optional_move_base &rhs) = default;
optional_move_base(optional_move_base &&rhs) noexcept(
std::is_nothrow_mo
gitextract_mlo6v1x3/ ├── .clang-format ├── .clang-tidy ├── .gitignore ├── .gitmodules ├── CMake/ │ ├── DownloadProject.CMakeLists.cmake.in │ ├── DownloadProject.LICENSE │ ├── DownloadProject.cmake │ ├── FindWayland.cmake │ └── FindXCB.cmake ├── CMake-Utils/ │ ├── setup_cpp.cmake │ ├── setup_cuda.cmake │ ├── setup_externallibs.cmake │ └── setup_python.cmake ├── CMakeLists.txt ├── Externals/ │ ├── CMakeLists.txt │ ├── SDFGen/ │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ ├── array1.h │ │ ├── array2.h │ │ ├── array3.h │ │ ├── config.h.in │ │ ├── hashgrid.h │ │ ├── hashtable.h │ │ ├── main.cpp │ │ ├── makelevelset3.cpp │ │ ├── makelevelset3.h │ │ ├── util.h │ │ └── vec.h │ ├── function_ref/ │ │ └── tl/ │ │ └── function_ref.hpp │ ├── optional/ │ │ └── tl/ │ │ └── optional.hpp │ ├── partio/ │ │ ├── CMakeLists.txt │ │ ├── Partio.h │ │ ├── PartioAttribute.h │ │ ├── PartioIterator.h │ │ ├── PartioVec3.h │ │ ├── core/ │ │ │ ├── KdTree.h │ │ │ ├── Mutex.h │ │ │ ├── Particle.cpp │ │ │ ├── ParticleCaching.cpp │ │ │ ├── ParticleCaching.h │ │ │ ├── ParticleHeaders.cpp │ │ │ ├── ParticleHeaders.h │ │ │ ├── ParticleSimple.cpp │ │ │ ├── ParticleSimple.h │ │ │ ├── ParticleSimpleInterleave.cpp │ │ │ └── ParticleSimpleInterleave.h │ │ └── io/ │ │ ├── BGEO.cpp │ │ ├── BIN.cpp │ │ ├── GEO.cpp │ │ ├── MC.cpp │ │ ├── PDA.cpp │ │ ├── PDB.cpp │ │ ├── PDC.cpp │ │ ├── PRT.cppbak │ │ ├── PTC.cpp │ │ ├── PTS.cpp │ │ ├── ParticleIO.cpp │ │ ├── PartioEndian.h │ │ ├── RIB.cpp │ │ ├── ZIP.cpp │ │ ├── ZIP.h │ │ ├── half2float.h │ │ ├── pdb.h │ │ └── readers.h │ └── variant/ │ └── mpark/ │ ├── config.hpp │ ├── in_place.hpp │ ├── lib.hpp │ └── variant.hpp ├── LICENSE ├── Library/ │ ├── CMakeLists.txt │ ├── MnBase/ │ │ ├── Algorithm/ │ │ │ ├── MappingKernels.cuh │ │ │ ├── ParallelPatterns.cuh │ │ │ └── SortKernels.cuh │ │ ├── Concurrency/ │ │ │ └── Concurrency.h │ │ ├── DataStructure/ │ │ │ ├── Bvh/ │ │ │ │ └── Bvh.cuh │ │ │ ├── FSM/ │ │ │ │ └── FiniteStateMachine.h │ │ │ └── Hash/ │ │ │ └── Hash.cuh │ │ ├── Geometry/ │ │ │ └── GeometrySampler.h │ │ ├── Math/ │ │ │ ├── Bit/ │ │ │ │ ├── Bits.h │ │ │ │ └── SpatialEncoder.cuh │ │ │ ├── Matrix/ │ │ │ │ ├── EigenDecomposition.cuh │ │ │ │ ├── Givens.cuh │ │ │ │ ├── MatrixKernels.cuh │ │ │ │ ├── MatrixUtils.h │ │ │ │ ├── Utility.h │ │ │ │ ├── qr.cuh │ │ │ │ └── svd.cuh │ │ │ ├── Probability/ │ │ │ │ ├── Probability.cpp │ │ │ │ └── Probability.h │ │ │ └── Vec.h │ │ ├── Memory/ │ │ │ ├── Allocator.h │ │ │ ├── MemObj.h │ │ │ └── MemoryResource.h │ │ ├── Meta/ │ │ │ ├── AllocMeta.cuh │ │ │ ├── ControlFlow.h │ │ │ ├── Functional.h │ │ │ ├── MathMeta.h │ │ │ ├── Meta.h │ │ │ ├── Optional.h │ │ │ ├── PatternMeta.h │ │ │ ├── Polymorphism.h │ │ │ ├── Relationship.h │ │ │ ├── TupleMeta.h │ │ │ ├── TypeDecoration.h │ │ │ ├── TypeIdentity.h │ │ │ ├── TypeMeta.h │ │ │ ├── TypeOperation.h │ │ │ └── TypeProperty.h │ │ ├── Object/ │ │ │ ├── Function.h │ │ │ ├── Property.h │ │ │ ├── Structural.h │ │ │ ├── StructuralAuxiliary.h │ │ │ └── StructuralDeclaration.h │ │ ├── Profile/ │ │ │ ├── CppTimers.hpp │ │ │ └── CudaTimers.cuh │ │ ├── Reflection.h │ │ └── Singleton.h │ └── MnSystem/ │ ├── CMakeLists.txt │ ├── Cuda/ │ │ ├── Allocators.cuh │ │ ├── Cuda.cu │ │ ├── Cuda.h │ │ ├── DeviceUtils.cu │ │ ├── DeviceUtils.cuh │ │ ├── ExecutionPolicy.h │ │ ├── HostUtils.hpp │ │ ├── KernelLauncher.cuh │ │ ├── MemoryUtils.cu │ │ └── MemoryUtils.cuh │ ├── IO/ │ │ ├── IO.cpp │ │ ├── IO.h │ │ ├── ParticleIO.hpp │ │ └── PoissonDisk/ │ │ ├── PoissonDisk.h │ │ ├── SampleGenerator.h │ │ ├── cyCore.h │ │ ├── cyHeap.h │ │ ├── cyPoint.h │ │ ├── cyPointCloud.h │ │ └── cySampleElim.h │ └── sourcelist.cmake ├── Projects/ │ ├── CMakeLists.txt │ ├── GMPM/ │ │ ├── CMakeLists.txt │ │ ├── constitutive_models.cuh │ │ ├── gmpm.cu │ │ ├── gmpm_simulator.cuh │ │ ├── grid_buffer.cuh │ │ ├── hash_table.cuh │ │ ├── mgmpm_kernels.cuh │ │ ├── particle_buffer.cuh │ │ ├── partition_domain.h │ │ ├── scenes/ │ │ │ └── scene.json │ │ ├── settings.h │ │ └── utility_funcs.hpp │ ├── MGSP/ │ │ ├── CMakeLists.txt │ │ ├── boundary_condition.cuh │ │ ├── constitutive_models.cuh │ │ ├── grid_buffer.cuh │ │ ├── halo_buffer.cuh │ │ ├── halo_kernels.cuh │ │ ├── hash_table.cuh │ │ ├── mgmpm_kernels.cuh │ │ ├── mgsp.cu │ │ ├── mgsp_benchmark.cuh │ │ ├── particle_buffer.cuh │ │ ├── partition_domain.h │ │ ├── settings.h │ │ └── utility_funcs.hpp │ └── TaichiScripts/ │ └── gmpm.py ├── README.md ├── docs/ │ ├── benchmark.rst │ ├── compilation.rst │ ├── conf.py │ ├── credits.rst │ ├── datastructure.rst │ ├── index.rst │ ├── multigmpm.rst │ ├── overview.rst │ ├── philosophy.rst │ ├── pipeline.rst │ ├── sparsity.rst │ ├── structural.rst │ ├── system.rst │ └── usage.rst └── project_info.in
Showing preview only (240K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (1235 symbols across 98 files)
FILE: Externals/SDFGen/array1.h
type Array1True (line 23) | struct Array1True {}
type Array1False (line 24) | struct Array1False {}
type Array1False (line 25) | typedef Array1False type;
function bool (line 26) | struct Array1IsIntegral<bool>{ typedef Array1True type; }
function char (line 27) | struct Array1IsIntegral<char>{ typedef Array1True type; }
function signed (line 28) | struct Array1IsIntegral<signed char>{ typedef Array1True type; }
function unsigned (line 29) | struct Array1IsIntegral<unsigned char>{ typedef Array1True type; }
function short (line 30) | struct Array1IsIntegral<short>{ typedef Array1True type; }
function unsigned (line 31) | struct Array1IsIntegral<unsigned short>{ typedef Array1True type; }
function int (line 32) | struct Array1IsIntegral<int>{ typedef Array1True type; }
function unsigned (line 33) | struct Array1IsIntegral<unsigned int>{ typedef Array1True type; }
function long (line 34) | struct Array1IsIntegral<long>{ typedef Array1True type; }
function unsigned (line 35) | struct Array1IsIntegral<unsigned long>{ typedef Array1True type; }
type Array1IsIntegral (line 36) | struct Array1IsIntegral
type Array1True (line 36) | typedef Array1True type;
type Array1IsIntegral (line 37) | struct Array1IsIntegral
type Array1True (line 37) | typedef Array1True type;
type T (line 45) | typedef T* iterator;
type T (line 46) | typedef const T* const_iterator;
type size_type (line 47) | typedef unsigned long size_type;
type difference_type (line 48) | typedef long difference_type;
type T (line 49) | typedef T& reference;
type T (line 50) | typedef const T& const_reference;
type T (line 51) | typedef T value_type;
type T (line 52) | typedef T* pointer;
type T (line 53) | typedef const T* const_pointer;
type std (line 54) | typedef std::reverse_iterator<iterator> reverse_iterator;
type std (line 55) | typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
function T (line 147) | const T& operator[](unsigned long i) const
function T (line 154) | const T& operator()(unsigned long i) const
function operator (line 180) | bool operator==(const Array1<T>& x) const
function operator (line 187) | bool operator!=(const Array1<T>& x) const
function operator (line 194) | bool operator<(const Array1<T>& x) const
function operator (line 203) | bool operator>(const Array1<T>& x) const
function operator (line 212) | bool operator<=(const Array1<T>& x) const
function operator (line 221) | bool operator>=(const Array1<T>& x) const
function add_unique (line 230) | void add_unique(const T& value)
function assign (line 237) | void assign(const T& value)
function assign (line 240) | void assign(unsigned long num, const T& value)
function assign (line 245) | void assign(unsigned long num, const T* copydata)
function T (line 279) | const T& at(unsigned long i) const
function T (line 291) | const T& back(void) const
function T (line 303) | const T* begin(void) const
function T (line 306) | T* begin(void)
function capacity (line 309) | unsigned long capacity(void) const
function clear (line 312) | void clear(void)
function empty (line 320) | bool empty(void) const
function T (line 323) | const T* end(void) const
function T (line 326) | T* end(void)
function erase (line 329) | void erase(unsigned long index)
function fill (line 337) | void fill(unsigned long num, const T& value)
function T (line 350) | const T& front(void) const
function grow (line 362) | void grow(void)
function insert (line 371) | void insert(unsigned long index, const T& entry)
function max_size (line 380) | unsigned long max_size(void) const
function pop_back (line 383) | void pop_back(void)
function push_back (line 389) | void push_back(const T& value)
function reverse_iterator (line 395) | reverse_iterator rbegin(void)
function const_reverse_iterator (line 398) | const_reverse_iterator rbegin(void) const
function reverse_iterator (line 401) | reverse_iterator rend(void)
function const_reverse_iterator (line 404) | const_reverse_iterator rend(void) const
function reserve (line 407) | void reserve(unsigned long r)
function resize (line 416) | void resize(unsigned long n_)
function resize (line 422) | void resize(unsigned long n_, const T& value)
function set_zero (line 429) | void set_zero(void)
function size (line 432) | unsigned long size(void) const
function swap (line 435) | void swap(Array1<T>& x)
function trim (line 444) | void trim(void)
type Array1 (line 458) | typedef Array1<double> Array1d;
type Array1 (line 459) | typedef Array1<float> Array1f;
type Array1ll (line 460) | typedef Array1<long long> Array1ll;
type Array1ull (line 461) | typedef Array1<unsigned long long> Array1ull;
type Array1 (line 462) | typedef Array1<int> Array1i;
type Array1ui (line 463) | typedef Array1<unsigned int> Array1ui;
type Array1s (line 464) | typedef Array1<short> Array1s;
type Array1us (line 465) | typedef Array1<unsigned short> Array1us;
type Array1 (line 466) | typedef Array1<char> Array1c;
type Array1uc (line 467) | typedef Array1<unsigned char> Array1uc;
type T (line 475) | typedef T* iterator;
type T (line 476) | typedef const T* const_iterator;
type size_type (line 477) | typedef unsigned long size_type;
type difference_type (line 478) | typedef long difference_type;
type T (line 479) | typedef T& reference;
type T (line 480) | typedef const T& const_reference;
type T (line 481) | typedef T value_type;
type T (line 482) | typedef T* pointer;
type T (line 483) | typedef const T* const_pointer;
type std (line 484) | typedef std::reverse_iterator<iterator> reverse_iterator;
type std (line 485) | typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
function init (line 521) | void init(unsigned long n_, T* data_, unsigned long max_n_)
function T (line 530) | const T& operator[](unsigned long i) const
function T (line 537) | const T& operator()(unsigned long i) const
function add_unique (line 599) | void add_unique(const T& value)
function assign (line 606) | void assign(const T& value)
function assign (line 609) | void assign(unsigned long num, const T& value)
function assign (line 614) | void assign(unsigned long num, const T* copydata)
function T (line 642) | const T& at(unsigned long i) const
function T (line 654) | const T& back(void) const
function T (line 666) | const T* begin(void) const
function T (line 669) | T* begin(void)
function capacity (line 672) | unsigned long capacity(void) const
function clear (line 675) | void clear(void)
function empty (line 678) | bool empty(void) const
function T (line 681) | const T* end(void) const
function T (line 684) | T* end(void)
function erase (line 687) | void erase(unsigned long index)
function fill (line 695) | void fill(unsigned long num, const T& value)
function T (line 702) | const T& front(void) const
function insert (line 714) | void insert(unsigned long index, const T& entry)
function max_size (line 723) | unsigned long max_size(void) const
function pop_back (line 726) | void pop_back(void)
function push_back (line 732) | void push_back(const T& value)
function reverse_iterator (line 738) | reverse_iterator rbegin(void)
function const_reverse_iterator (line 741) | const_reverse_iterator rbegin(void) const
function reverse_iterator (line 744) | reverse_iterator rend(void)
function const_reverse_iterator (line 747) | const_reverse_iterator rend(void) const
function reserve (line 750) | void reserve(unsigned long r)
function resize (line 753) | void resize(unsigned long n_)
function resize (line 759) | void resize(unsigned long n_, const T& value)
function set_zero (line 767) | void set_zero(void)
function size (line 770) | unsigned long size(void) const
function swap (line 773) | void swap(WrapArray1<T>& x)
type WrapArray1 (line 783) | typedef WrapArray1<double> WrapArray1d;
type WrapArray1 (line 784) | typedef WrapArray1<float> WrapArray1f;
type WrapArray1ll (line 785) | typedef WrapArray1<long long> WrapArray1ll;
type WrapArray1ull (line 786) | typedef WrapArray1<unsigned long long> WrapArray1ull;
type WrapArray1 (line 787) | typedef WrapArray1<int> WrapArray1i;
type WrapArray1ui (line 788) | typedef WrapArray1<unsigned int> WrapArray1ui;
type WrapArray1s (line 789) | typedef WrapArray1<short> WrapArray1s;
type WrapArray1us (line 790) | typedef WrapArray1<unsigned short> WrapArray1us;
type WrapArray1 (line 791) | typedef WrapArray1<char> WrapArray1c;
type WrapArray1uc (line 792) | typedef WrapArray1<unsigned char> WrapArray1uc;
FILE: Externals/SDFGen/array2.h
type Array2 (line 10) | struct Array2
function T (line 73) | const T& operator()(int i, int j) const
function operator (line 85) | bool operator==(const Array2<T>& x) const
function operator (line 88) | bool operator!=(const Array2<T>& x) const
function operator (line 91) | bool operator<(const Array2<T>& x) const
function operator (line 98) | bool operator>(const Array2<T>& x) const
function operator (line 105) | bool operator<=(const Array2<T>& x) const
function operator (line 112) | bool operator>=(const Array2<T>& x) const
function assign (line 119) | void assign(const T& value)
function assign (line 122) | void assign(int ni_, int nj_, const T& value)
function assign (line 129) | void assign(int ni_, int nj_, const T* copydata)
function T (line 136) | const T& at(int i, int j) const
function T (line 148) | const T& back(void) const
function const_iterator (line 160) | const_iterator begin(void) const
function iterator (line 163) | iterator begin(void)
function size_type (line 166) | size_type capacity(void) const
function clear (line 169) | void clear(void)
function empty (line 175) | bool empty(void) const
function const_iterator (line 178) | const_iterator end(void) const
function iterator (line 181) | iterator end(void)
function fill (line 184) | void fill(int ni_, int nj_, const T& value)
function T (line 191) | const T& front(void) const
function size_type (line 203) | size_type max_size(void) const
function reverse_iterator (line 206) | reverse_iterator rbegin(void)
function const_reverse_iterator (line 209) | const_reverse_iterator rbegin(void) const
function reverse_iterator (line 212) | reverse_iterator rend(void)
function const_reverse_iterator (line 215) | const_reverse_iterator rend(void) const
function reserve (line 218) | void reserve(int reserve_ni, int reserve_nj)
function resize (line 221) | void resize(int ni_, int nj_)
function resize (line 229) | void resize(int ni_, int nj_, const T& value)
function set_zero (line 237) | void set_zero(void)
function size_type (line 240) | size_type size(void) const
function swap (line 243) | void swap(Array2<T>& x)
function trim (line 250) | void trim(void)
type Array2 (line 256) | typedef Array2<double, Array1<double> > Array2d;
type Array2 (line 257) | typedef Array2<float, Array1<float> > Array2f;
type Array2ll (line 258) | typedef Array2<long long, Array1<long long> > Array2ll;
type Array2ull (line 259) | typedef Array2<unsigned long long, Array1<unsigned long long> > Array2ull;
type Array2 (line 260) | typedef Array2<int, Array1<int> > Array2i;
type Array2ui (line 261) | typedef Array2<unsigned int, Array1<unsigned int> > Array2ui;
type Array2 (line 262) | typedef Array2<short, Array1<short> > Array2s;
type Array2us (line 263) | typedef Array2<unsigned short, Array1<unsigned short> > Array2us;
type Array2 (line 264) | typedef Array2<char, Array1<char> > Array2c;
type Array2uc (line 265) | typedef Array2<unsigned char, Array1<unsigned char> > Array2uc;
type Array2 (line 269) | typedef Array2<double, WrapArray1<double> > Wrap...
type Array2 (line 270) | typedef Array2<float, WrapArray1<float> > Wrap...
type WrapArray2ll (line 271) | typedef Array2<long long, WrapArray1<long long> > Wrap...
type WrapArray2ull (line 272) | typedef Array2<unsigned long long, WrapArray1<unsigned long long> > Wrap...
type Array2 (line 273) | typedef Array2<int, WrapArray1<int> > Wrap...
type WrapArray2ui (line 274) | typedef Array2<unsigned int, WrapArray1<unsigned int> > Wrap...
type Array2 (line 275) | typedef Array2<short, WrapArray1<short> > Wrap...
type WrapArray2us (line 276) | typedef Array2<unsigned short, WrapArray1<unsigned short> > Wrap...
type Array2 (line 277) | typedef Array2<char, WrapArray1<char> > Wrap...
type WrapArray2uc (line 278) | typedef Array2<unsigned char, WrapArray1<unsigned char> > Wrap...
FILE: Externals/SDFGen/array3.h
type Array3 (line 10) | struct Array3
function operator (line 80) | bool operator==(const Array3<T>& x) const
function operator (line 83) | bool operator!=(const Array3<T>& x) const
function operator (line 86) | bool operator<(const Array3<T>& x) const
function operator (line 94) | bool operator>(const Array3<T>& x) const
function operator (line 102) | bool operator<=(const Array3<T>& x) const
function operator (line 110) | bool operator>=(const Array3<T>& x) const
function assign (line 118) | void assign(const T& value)
function assign (line 121) | void assign(int ni_, int nj_, int nk_, const T& value)
function assign (line 129) | void assign(int ni_, int nj_, int nk_, const T* copydata)
function T (line 137) | const T& at(int i, int j, int k) const
function T (line 149) | const T& back(void) const
function const_iterator (line 161) | const_iterator begin(void) const
function iterator (line 164) | iterator begin(void)
function size_type (line 167) | size_type capacity(void) const
function clear (line 170) | void clear(void)
function empty (line 176) | bool empty(void) const
function const_iterator (line 179) | const_iterator end(void) const
function iterator (line 182) | iterator end(void)
function fill (line 185) | void fill(int ni_, int nj_, int nk_, const T& value)
function T (line 193) | const T& front(void) const
function size_type (line 205) | size_type max_size(void) const
function reverse_iterator (line 208) | reverse_iterator rbegin(void)
function const_reverse_iterator (line 211) | const_reverse_iterator rbegin(void) const
function reverse_iterator (line 214) | reverse_iterator rend(void)
function const_reverse_iterator (line 217) | const_reverse_iterator rend(void) const
function reserve (line 220) | void reserve(int reserve_ni, int reserve_nj, int reserve_nk)
function resize (line 223) | void resize(int ni_, int nj_, int nk_)
function resize (line 232) | void resize(int ni_, int nj_, int nk_, const T& value)
function set_zero (line 241) | void set_zero(void)
function size_type (line 244) | size_type size(void) const
function swap (line 247) | void swap(Array3<T>& x)
function trim (line 255) | void trim(void)
type Array3 (line 261) | typedef Array3<double, Array1<double> > Array3d;
type Array3 (line 262) | typedef Array3<float, Array1<float> > Array3f;
type Array3ll (line 263) | typedef Array3<long long, Array1<long long> > Array3ll;
type Array3ull (line 264) | typedef Array3<unsigned long long, Array1<unsigned long long> > Array3ull;
type Array3 (line 265) | typedef Array3<int, Array1<int> > Array3i;
type Array3ui (line 266) | typedef Array3<unsigned int, Array1<unsigned int> > Array3ui;
type Array3 (line 267) | typedef Array3<short, Array1<short> > Array3s;
type Array3us (line 268) | typedef Array3<unsigned short, Array1<unsigned short> > Array3us;
type Array3 (line 269) | typedef Array3<char, Array1<char> > Array3c;
type Array3uc (line 270) | typedef Array3<unsigned char, Array1<unsigned char> > Array3uc;
FILE: Externals/SDFGen/hashgrid.h
function add_point (line 23) | void add_point(const Vec2d &x, const DataType &datum)
function delete_point (line 26) | void delete_point(const Vec2d &x, const DataType &datum)
function add_box (line 29) | void add_box(const Vec2d &xmin, const Vec2d &xmax, const DataType &datum)
function delete_box (line 36) | void delete_box(const Vec2d &xmin, const Vec2d &xmax, const DataType &da...
function size (line 43) | unsigned int size(void) const
function clear (line 46) | void clear(void)
function reserve (line 49) | void reserve(unsigned int expected_size)
function find_first_point (line 52) | bool find_first_point(const Vec2d &x, DataType &datum) const
function find_point (line 55) | bool find_point(const Vec2d &x, std::vector<DataType> &data_list) const
function find_box (line 62) | bool find_box(const Vec2d &xmin, const Vec2d &xmax, std::vector<DataType...
function add_point (line 88) | void add_point(const Vec3d &x, const DataType &datum)
function delete_point (line 91) | void delete_point(const Vec3d &x, const DataType &datum)
function add_box (line 94) | void add_box(const Vec3d &xmin, const Vec3d &xmax, const DataType &datum)
function delete_box (line 101) | void delete_box(const Vec3d &xmin, const Vec3d &xmax, const DataType &da...
function size (line 108) | unsigned int size(void) const
function clear (line 111) | void clear(void)
function reserve (line 114) | void reserve(unsigned int expected_size)
function find_first_point (line 117) | bool find_first_point(const Vec3d &x, DataType &index) const
function find_point (line 120) | bool find_point(const Vec3d &x, std::vector<DataType> &data_list) const
function find_box (line 127) | bool find_box(const Vec3d &xmin, const Vec3d &xmax, std::vector<DataType...
FILE: Externals/SDFGen/hashtable.h
function hash (line 17) | inline unsigned int hash(unsigned int k)
type DefaultHashFunction (line 21) | struct DefaultHashFunction
type equal (line 27) | struct equal
function init (line 53) | void init(unsigned int expected_size)
function add (line 72) | void add(const Key &k, const Data &d)
function delete_entry (line 86) | void delete_entry(const Key &k, const Data &d) // delete first entry tha...
function clear (line 105) | void clear()
function reserve (line 117) | void reserve(unsigned int expected_size)
function has_entry (line 156) | bool has_entry(const Key &k) const
function get_entry (line 168) | bool get_entry(const Key &k, Data &data_return) const
function append_all_entries (line 182) | void append_all_entries(const Key& k, std::vector<Data>& data_return) const
function Data (line 205) | const Data &operator() (const Key &k, const Data &missing_data) const
FILE: Externals/SDFGen/main.cpp
function main (line 23) | int main(int argc, char* argv[]) {
FILE: Externals/SDFGen/makelevelset3.cpp
function point_segment_distance (line 4) | static float point_segment_distance(const Vec3f &x0, const Vec3f &x1, co...
function point_triangle_distance (line 20) | static float point_triangle_distance(const Vec3f &x0, const Vec3f &x1, c...
function check_neighbour (line 43) | static void check_neighbour(const std::vector<Vec3ui> &tri, const std::v...
function sweep (line 57) | static void sweep(const std::vector<Vec3ui> &tri, const std::vector<Vec3...
function orientation (line 84) | static int orientation(double x1, double y1, double x2, double y2, doubl...
function point_in_triangle_2d (line 98) | static bool point_in_triangle_2d(double x0, double y0,
function make_level_set3 (line 118) | void make_level_set3(const std::vector<Vec3ui> &tri, const std::vector<V...
FILE: Externals/SDFGen/util.h
function T (line 23) | T sqr(const T& x)
function T (line 27) | T cube(const T& x)
function T (line 31) | T min(T a1, T a2, T a3)
function T (line 35) | T min(T a1, T a2, T a3, T a4)
function T (line 39) | T min(T a1, T a2, T a3, T a4, T a5)
function T (line 43) | T min(T a1, T a2, T a3, T a4, T a5, T a6)
function T (line 47) | T max(T a1, T a2, T a3)
function T (line 51) | T max(T a1, T a2, T a3, T a4)
function T (line 55) | T max(T a1, T a2, T a3, T a4, T a5)
function T (line 59) | T max(T a1, T a2, T a3, T a4, T a5, T a6)
function minmax (line 63) | void minmax(T a1, T a2, T& amin, T& amax)
function minmax (line 75) | void minmax(T a1, T a2, T a3, T& amin, T& amax)
function minmax (line 100) | void minmax(T a1, T a2, T a3, T a4, T& amin, T& amax)
function minmax (line 122) | void minmax(T a1, T a2, T a3, T a4, T a5, T& amin, T& amax)
function minmax (line 130) | void minmax(T a1, T a2, T a3, T a4, T a5, T a6, T& amin, T& amax)
function update_minmax (line 138) | void update_minmax(T a1, T& amin, T& amax)
function T (line 170) | T clamp(T a, T lower, T upper)
function T (line 179) | T smooth_step(T r)
function T (line 188) | T smooth_step(T r, T r_lower, T r_upper, T value_lower, T value_upper)
function T (line 193) | T ramp(T r)
function lround (line 197) | inline int lround(double x)
function remainder (line 205) | inline double remainder(double x, double y)
function round_up_to_power_of_two (line 211) | inline unsigned int round_up_to_power_of_two(unsigned int n)
function round_down_to_power_of_two (line 222) | inline unsigned int round_down_to_power_of_two(unsigned int n)
function randhash (line 235) | inline unsigned int randhash(unsigned int seed)
function unhash (line 246) | inline unsigned int unhash(unsigned int h)
function randhashd (line 258) | inline double randhashd(unsigned int seed)
function randhashf (line 260) | inline float randhashf(unsigned int seed)
function randhashd (line 264) | inline double randhashd(unsigned int seed, double a, double b)
function randhashf (line 266) | inline float randhashf(unsigned int seed, float a, float b)
function intlog2 (line 269) | inline int intlog2(int x)
function get_barycentric (line 280) | void get_barycentric(T x, int& i, T& f, int i_low, int i_high)
function S (line 295) | S lerp(const S& value0, const S& value1, T f)
function S (line 299) | S bilerp(const S& v00, const S& v10,
function S (line 309) | S trilerp(const S& v000, const S& v100,
function S (line 321) | S quadlerp(const S& v0000, const S& v1000,
function quadratic_bspline_weights (line 338) | void quadratic_bspline_weights(T f, T& w0, T& w1, T& w2)
function cubic_interp_weights (line 347) | void cubic_interp_weights(T f, T& wneg1, T& w0, T& w1, T& w2)
function S (line 357) | S cubic_interp(const S& value_neg1, const S& value0, const S& value1, co...
FILE: Externals/SDFGen/vec.h
type Vec (line 22) | struct Vec
function T (line 76) | const T &operator[](int index) const
function nonzero (line 82) | bool nonzero(void) const
type Vec2ui (line 164) | typedef Vec<2,unsigned int> Vec2ui;
type Vec2us (line 166) | typedef Vec<2,unsigned short> Vec2us;
type Vec2uc (line 168) | typedef Vec<2,unsigned char> Vec2uc;
type Vec3ui (line 173) | typedef Vec<3,unsigned int> Vec3ui;
type Vec3us (line 175) | typedef Vec<3,unsigned short> Vec3us;
type Vec3uc (line 177) | typedef Vec<3,unsigned char> Vec3uc;
type Vec4ui (line 182) | typedef Vec<4,unsigned int> Vec4ui;
type Vec4us (line 184) | typedef Vec<4,unsigned short> Vec4us;
type Vec4uc (line 186) | typedef Vec<4,unsigned char> Vec4uc;
type Vec6ui (line 190) | typedef Vec<6,unsigned int> Vec6ui;
type Vec6us (line 193) | typedef Vec<6,unsigned short> Vec6us;
type Vec6uc (line 195) | typedef Vec<6,unsigned char> Vec6uc;
function T (line 348) | T cross(const Vec<2,T> &a, const Vec<2,T> &b)
function T (line 356) | T triple(const Vec<3,T> &a, const Vec<3,T> &b, const Vec<3,T> &c)
function hash (line 362) | inline unsigned int hash(const Vec<N,T> &a)
FILE: Externals/function_ref/tl/function_ref.hpp
type tl (line 64) | namespace tl {
type detail (line 65) | namespace detail {
type fnref (line 66) | namespace fnref {
function invoke (line 82) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 90) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 97) | struct invoke_result_impl
type is_invocable_r_impl (line 113) | struct is_invocable_r_impl : std::false_type {}
class function_ref (line 136) | class function_ref
function swap (line 201) | constexpr void swap(function_ref<R(Args...)> &lhs,
type invoke_result_impl<
F, decltype(tl::detail::fnref::invoke(std::declval<F>(), std::declval<Us>()...), void()),
Us...> (line 100) | struct invoke_result_impl<
type is_invocable_r_impl<
typename std::is_convertible<invoke_result_t<F, Args...>, R>::type, R, F, Args...> (line 116) | struct is_invocable_r_impl<
class function_ref<R(Args...)> (line 139) | class function_ref<R(Args...)> {
method function_ref (line 141) | constexpr function_ref() noexcept = delete;
method function_ref (line 144) | constexpr function_ref(const function_ref<R(Args...)> &rhs) noexcept =...
method TL_FUNCTION_REF_11_CONSTEXPR (line 153) | TL_FUNCTION_REF_11_CONSTEXPR function_ref(F &&f) noexcept
method TL_FUNCTION_REF_11_CONSTEXPR (line 163) | TL_FUNCTION_REF_11_CONSTEXPR function_ref<R(Args...)> &
method TL_FUNCTION_REF_11_CONSTEXPR (line 172) | TL_FUNCTION_REF_11_CONSTEXPR function_ref<R(Args...)> &operator=(F &&f...
method swap (line 184) | constexpr void swap(function_ref<R(Args...)> &rhs) noexcept {
method R (line 190) | R operator()(Args... args) const {
FILE: Externals/optional/tl/optional.hpp
type tl (line 68) | namespace tl {
type detail (line 69) | namespace detail {
type is_trivially_copy_constructible (line 71) | struct is_trivially_copy_constructible : std::is_trivially_copy_cons...
type is_trivially_copy_constructible<std::vector<T,A>> (line 74) | struct is_trivially_copy_constructible<std::vector<T,A>>
type conjunction (line 136) | struct conjunction : std::true_type {}
type conjunction<B> (line 137) | struct conjunction<B> : B {}
type is_pointer_to_non_const_member_func (line 150) | struct is_pointer_to_non_const_member_func : std::false_type{}
type is_const_or_const_ref (line 164) | struct is_const_or_const_ref : std::false_type{}
type is_const_or_const_ref<T const&> (line 165) | struct is_const_or_const_ref<T const&> : std::true_type{}
type is_const_or_const_ref<T const> (line 166) | struct is_const_or_const_ref<T const> : std::true_type{}
function invoke (line 178) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 186) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 193) | struct invoke_result_impl
type is_swappable (line 210) | struct is_swappable : std::true_type {}
type is_nothrow_swappable (line 212) | struct is_nothrow_swappable : std::true_type {}
type swap_adl_tests (line 215) | namespace swap_adl_tests {
type tag (line 218) | struct tag {}
type is_std_swap_noexcept (line 237) | struct is_std_swap_noexcept
type is_std_swap_noexcept<T[N]> (line 243) | struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}
type is_adl_swap_noexcept (line 246) | struct is_adl_swap_noexcept
type is_swappable (line 251) | struct is_swappable
type is_swappable<T[N], T[N]> (line 260) | struct is_swappable<T[N], T[N]>
type is_nothrow_swappable (line 269) | struct is_nothrow_swappable
type voider (line 283) | struct voider { using type = void; }
type is_optional_impl (line 287) | struct is_optional_impl : std::false_type {}
type is_optional_impl<optional<T>> (line 288) | struct is_optional_impl<optional<T>> : std::true_type {}
type returns_void_impl (line 299) | struct returns_void_impl
type optional_storage_base (line 358) | struct optional_storage_base {
method TL_OPTIONAL_11_CONSTEXPR (line 363) | TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
type dummy (line 373) | struct dummy {}
type optional_storage_base<T, true> (line 383) | struct optional_storage_base<T, true> {
type dummy (line 393) | struct dummy {}
type optional_operations_base (line 404) | struct optional_operations_base : optional_storage_base<T> {
method hard_reset (line 407) | void hard_reset() noexcept {
method construct (line 412) | void construct(Args &&... args) noexcept {
method assign (line 417) | void assign(Opt &&rhs) {
method has_value (line 432) | bool has_value() const { return this->m_has_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 434) | TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 435) | TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_v...
method TL_OPTIONAL_11_CONSTEXPR (line 436) | TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_v...
method T (line 438) | constexpr const T &&get() const && { return std::move(this->m_valu...
type optional_copy_base (line 445) | struct optional_copy_base : optional_operations_base<T> {
type optional_copy_base<T, false> (line 451) | struct optional_copy_base<T, false> : optional_operations_base<T> {
method optional_copy_base (line 454) | optional_copy_base() = default;
method optional_copy_base (line 455) | optional_copy_base(const optional_copy_base &rhs) {
method optional_copy_base (line 463) | optional_copy_base(optional_copy_base &&rhs) = default;
method optional_copy_base (line 464) | optional_copy_base &operator=(const optional_copy_base &rhs) = def...
method optional_copy_base (line 465) | optional_copy_base &operator=(optional_copy_base &&rhs) = default;
type optional_move_base (line 475) | struct optional_move_base : optional_copy_base<T> {
type optional_move_base (line 479) | struct optional_move_base
type optional_move_base<T, false> (line 481) | struct optional_move_base<T, false> : optional_copy_base<T> {
method optional_move_base (line 484) | optional_move_base() = default;
method optional_move_base (line 485) | optional_move_base(const optional_move_base &rhs) = default;
method optional_move_base (line 487) | optional_move_base(optional_move_base &&rhs) noexcept(
method optional_move_base (line 495) | optional_move_base &operator=(const optional_move_base &rhs) = def...
method optional_move_base (line 496) | optional_move_base &operator=(optional_move_base &&rhs) = default;
type optional_copy_assign_base (line 503) | struct optional_copy_assign_base : optional_move_base<T> {
type optional_copy_assign_base<T, false> (line 508) | struct optional_copy_assign_base<T, false> : optional_move_base<T> {
method optional_copy_assign_base (line 511) | optional_copy_assign_base() = default;
method optional_copy_assign_base (line 512) | optional_copy_assign_base(const optional_copy_assign_base &rhs) = ...
method optional_copy_assign_base (line 514) | optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
method optional_copy_assign_base (line 515) | optional_copy_assign_base &operator=(const optional_copy_assign_ba...
method optional_copy_assign_base (line 519) | optional_copy_assign_base &
type optional_move_assign_base (line 532) | struct optional_move_assign_base : optional_copy_assign_base<T> {
type optional_move_assign_base (line 536) | struct optional_move_assign_base
type optional_move_assign_base<T, false> (line 540) | struct optional_move_assign_base<T, false> : optional_copy_assign_ba...
method optional_move_assign_base (line 543) | optional_move_assign_base() = default;
method optional_move_assign_base (line 544) | optional_move_assign_base(const optional_move_assign_base &rhs) = ...
method optional_move_assign_base (line 546) | optional_move_assign_base(optional_move_assign_base &&rhs) = default;
method optional_move_assign_base (line 548) | optional_move_assign_base &
method optional_move_assign_base (line 551) | optional_move_assign_base &
type optional_delete_ctor_base (line 564) | struct optional_delete_ctor_base {
method optional_delete_ctor_base (line 565) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 566) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 567) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 568) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 570) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, true, false> (line 574) | struct optional_delete_ctor_base<T, true, false> {
method optional_delete_ctor_base (line 575) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 576) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 577) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 578) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 580) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, true> (line 584) | struct optional_delete_ctor_base<T, false, true> {
method optional_delete_ctor_base (line 585) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 586) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 587) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 588) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 590) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, false> (line 594) | struct optional_delete_ctor_base<T, false, false> {
method optional_delete_ctor_base (line 595) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 596) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 597) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 598) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 600) | optional_delete_ctor_base &
type optional_delete_assign_base (line 611) | struct optional_delete_assign_base {
method optional_delete_assign_base (line 612) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 613) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 614) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 616) | optional_delete_assign_base &
method optional_delete_assign_base (line 618) | optional_delete_assign_base &
type optional_delete_assign_base<T, true, false> (line 622) | struct optional_delete_assign_base<T, true, false> {
method optional_delete_assign_base (line 623) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 624) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 625) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 627) | optional_delete_assign_base &
method optional_delete_assign_base (line 629) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, true> (line 633) | struct optional_delete_assign_base<T, false, true> {
method optional_delete_assign_base (line 634) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 635) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 636) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 638) | optional_delete_assign_base &
method optional_delete_assign_base (line 640) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, false> (line 644) | struct optional_delete_assign_base<T, false, false> {
method optional_delete_assign_base (line 645) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 646) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 647) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 649) | optional_delete_assign_base &
method optional_delete_assign_base (line 651) | optional_delete_assign_base &
class monostate (line 110) | class monostate {}
type in_place_t (line 113) | struct in_place_t {
method in_place_t (line 114) | explicit in_place_t() = default;
class optional (line 120) | class optional
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
type detail (line 122) | namespace detail {
type is_trivially_copy_constructible (line 71) | struct is_trivially_copy_constructible : std::is_trivially_copy_cons...
type is_trivially_copy_constructible<std::vector<T,A>> (line 74) | struct is_trivially_copy_constructible<std::vector<T,A>>
type conjunction (line 136) | struct conjunction : std::true_type {}
type conjunction<B> (line 137) | struct conjunction<B> : B {}
type is_pointer_to_non_const_member_func (line 150) | struct is_pointer_to_non_const_member_func : std::false_type{}
type is_const_or_const_ref (line 164) | struct is_const_or_const_ref : std::false_type{}
type is_const_or_const_ref<T const&> (line 165) | struct is_const_or_const_ref<T const&> : std::true_type{}
type is_const_or_const_ref<T const> (line 166) | struct is_const_or_const_ref<T const> : std::true_type{}
function invoke (line 178) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 186) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 193) | struct invoke_result_impl
type is_swappable (line 210) | struct is_swappable : std::true_type {}
type is_nothrow_swappable (line 212) | struct is_nothrow_swappable : std::true_type {}
type swap_adl_tests (line 215) | namespace swap_adl_tests {
type tag (line 218) | struct tag {}
type is_std_swap_noexcept (line 237) | struct is_std_swap_noexcept
type is_std_swap_noexcept<T[N]> (line 243) | struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}
type is_adl_swap_noexcept (line 246) | struct is_adl_swap_noexcept
type is_swappable (line 251) | struct is_swappable
type is_swappable<T[N], T[N]> (line 260) | struct is_swappable<T[N], T[N]>
type is_nothrow_swappable (line 269) | struct is_nothrow_swappable
type voider (line 283) | struct voider { using type = void; }
type is_optional_impl (line 287) | struct is_optional_impl : std::false_type {}
type is_optional_impl<optional<T>> (line 288) | struct is_optional_impl<optional<T>> : std::true_type {}
type returns_void_impl (line 299) | struct returns_void_impl
type optional_storage_base (line 358) | struct optional_storage_base {
method TL_OPTIONAL_11_CONSTEXPR (line 363) | TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
type dummy (line 373) | struct dummy {}
type optional_storage_base<T, true> (line 383) | struct optional_storage_base<T, true> {
type dummy (line 393) | struct dummy {}
type optional_operations_base (line 404) | struct optional_operations_base : optional_storage_base<T> {
method hard_reset (line 407) | void hard_reset() noexcept {
method construct (line 412) | void construct(Args &&... args) noexcept {
method assign (line 417) | void assign(Opt &&rhs) {
method has_value (line 432) | bool has_value() const { return this->m_has_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 434) | TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 435) | TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_v...
method TL_OPTIONAL_11_CONSTEXPR (line 436) | TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_v...
method T (line 438) | constexpr const T &&get() const && { return std::move(this->m_valu...
type optional_copy_base (line 445) | struct optional_copy_base : optional_operations_base<T> {
type optional_copy_base<T, false> (line 451) | struct optional_copy_base<T, false> : optional_operations_base<T> {
method optional_copy_base (line 454) | optional_copy_base() = default;
method optional_copy_base (line 455) | optional_copy_base(const optional_copy_base &rhs) {
method optional_copy_base (line 463) | optional_copy_base(optional_copy_base &&rhs) = default;
method optional_copy_base (line 464) | optional_copy_base &operator=(const optional_copy_base &rhs) = def...
method optional_copy_base (line 465) | optional_copy_base &operator=(optional_copy_base &&rhs) = default;
type optional_move_base (line 475) | struct optional_move_base : optional_copy_base<T> {
type optional_move_base (line 479) | struct optional_move_base
type optional_move_base<T, false> (line 481) | struct optional_move_base<T, false> : optional_copy_base<T> {
method optional_move_base (line 484) | optional_move_base() = default;
method optional_move_base (line 485) | optional_move_base(const optional_move_base &rhs) = default;
method optional_move_base (line 487) | optional_move_base(optional_move_base &&rhs) noexcept(
method optional_move_base (line 495) | optional_move_base &operator=(const optional_move_base &rhs) = def...
method optional_move_base (line 496) | optional_move_base &operator=(optional_move_base &&rhs) = default;
type optional_copy_assign_base (line 503) | struct optional_copy_assign_base : optional_move_base<T> {
type optional_copy_assign_base<T, false> (line 508) | struct optional_copy_assign_base<T, false> : optional_move_base<T> {
method optional_copy_assign_base (line 511) | optional_copy_assign_base() = default;
method optional_copy_assign_base (line 512) | optional_copy_assign_base(const optional_copy_assign_base &rhs) = ...
method optional_copy_assign_base (line 514) | optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
method optional_copy_assign_base (line 515) | optional_copy_assign_base &operator=(const optional_copy_assign_ba...
method optional_copy_assign_base (line 519) | optional_copy_assign_base &
type optional_move_assign_base (line 532) | struct optional_move_assign_base : optional_copy_assign_base<T> {
type optional_move_assign_base (line 536) | struct optional_move_assign_base
type optional_move_assign_base<T, false> (line 540) | struct optional_move_assign_base<T, false> : optional_copy_assign_ba...
method optional_move_assign_base (line 543) | optional_move_assign_base() = default;
method optional_move_assign_base (line 544) | optional_move_assign_base(const optional_move_assign_base &rhs) = ...
method optional_move_assign_base (line 546) | optional_move_assign_base(optional_move_assign_base &&rhs) = default;
method optional_move_assign_base (line 548) | optional_move_assign_base &
method optional_move_assign_base (line 551) | optional_move_assign_base &
type optional_delete_ctor_base (line 564) | struct optional_delete_ctor_base {
method optional_delete_ctor_base (line 565) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 566) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 567) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 568) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 570) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, true, false> (line 574) | struct optional_delete_ctor_base<T, true, false> {
method optional_delete_ctor_base (line 575) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 576) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 577) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 578) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 580) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, true> (line 584) | struct optional_delete_ctor_base<T, false, true> {
method optional_delete_ctor_base (line 585) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 586) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 587) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 588) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 590) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, false> (line 594) | struct optional_delete_ctor_base<T, false, false> {
method optional_delete_ctor_base (line 595) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 596) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 597) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 598) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 600) | optional_delete_ctor_base &
type optional_delete_assign_base (line 611) | struct optional_delete_assign_base {
method optional_delete_assign_base (line 612) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 613) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 614) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 616) | optional_delete_assign_base &
method optional_delete_assign_base (line 618) | optional_delete_assign_base &
type optional_delete_assign_base<T, true, false> (line 622) | struct optional_delete_assign_base<T, true, false> {
method optional_delete_assign_base (line 623) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 624) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 625) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 627) | optional_delete_assign_base &
method optional_delete_assign_base (line 629) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, true> (line 633) | struct optional_delete_assign_base<T, false, true> {
method optional_delete_assign_base (line 634) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 635) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 636) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 638) | optional_delete_assign_base &
method optional_delete_assign_base (line 640) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, false> (line 644) | struct optional_delete_assign_base<T, false, false> {
method optional_delete_assign_base (line 645) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 646) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 647) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 649) | optional_delete_assign_base &
method optional_delete_assign_base (line 651) | optional_delete_assign_base &
type nullopt_t (line 658) | struct nullopt_t {
type do_not_use (line 659) | struct do_not_use {}
method nullopt_t (line 660) | constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {}
class bad_optional_access (line 666) | class bad_optional_access : public std::exception {
method bad_optional_access (line 668) | bad_optional_access() = default;
class optional (line 679) | class optional : private detail::optional_move_assign_base<T>,
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1090) | constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)...
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1096) | optional(const optional<U> &rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1105) | explicit optional(const optional<U> &rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1115) | optional(optional<U> &&rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1124) | explicit optional(optional<U> &&rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1136) | optional &operator=(nullopt_t) noexcept {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1160) | optional &operator=(U &&u) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1176) | optional &operator=(const optional<U> &rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1198) | optional &operator=(optional<U> &&rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function T (line 1216) | T &emplace(Args &&... args) {
function emplace (line 1226) | detail::enable_if_t<
function swap (line 1241) | void
function T (line 1260) | constexpr const T *operator->() const {
function TL_OPTIONAL_11_CONSTEXPR (line 1264) | TL_OPTIONAL_11_CONSTEXPR T *operator->() {
function TL_OPTIONAL_11_CONSTEXPR (line 1269) | TL_OPTIONAL_11_CONSTEXPR T &operator*() & { return this->m_value; }
function T (line 1271) | constexpr const T &operator*() const & { return this->m_value; }
function TL_OPTIONAL_11_CONSTEXPR (line 1273) | TL_OPTIONAL_11_CONSTEXPR T &&operator*() && {
function T (line 1278) | constexpr const T &&operator*() const && { return std::move(this->m_va...
function has_value (line 1282) | constexpr bool has_value() const noexcept { return this->m_has_value; }
function TL_OPTIONAL_11_CONSTEXPR (line 1289) | TL_OPTIONAL_11_CONSTEXPR T &value() & {
function TL_OPTIONAL_11_CONSTEXPR (line 1294) | TL_OPTIONAL_11_CONSTEXPR const T &value() const & {
function TL_OPTIONAL_11_CONSTEXPR (line 1299) | TL_OPTIONAL_11_CONSTEXPR T &&value() && {
function TL_OPTIONAL_11_CONSTEXPR (line 1306) | TL_OPTIONAL_11_CONSTEXPR const T &&value() const && {
function T (line 1314) | constexpr T value_or(U &&u) const & {
function TL_OPTIONAL_11_CONSTEXPR (line 1321) | TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && {
function reset (line 1329) | void reset() noexcept {
type tl (line 106) | namespace tl {
type detail (line 69) | namespace detail {
type is_trivially_copy_constructible (line 71) | struct is_trivially_copy_constructible : std::is_trivially_copy_cons...
type is_trivially_copy_constructible<std::vector<T,A>> (line 74) | struct is_trivially_copy_constructible<std::vector<T,A>>
type conjunction (line 136) | struct conjunction : std::true_type {}
type conjunction<B> (line 137) | struct conjunction<B> : B {}
type is_pointer_to_non_const_member_func (line 150) | struct is_pointer_to_non_const_member_func : std::false_type{}
type is_const_or_const_ref (line 164) | struct is_const_or_const_ref : std::false_type{}
type is_const_or_const_ref<T const&> (line 165) | struct is_const_or_const_ref<T const&> : std::true_type{}
type is_const_or_const_ref<T const> (line 166) | struct is_const_or_const_ref<T const> : std::true_type{}
function invoke (line 178) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 186) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 193) | struct invoke_result_impl
type is_swappable (line 210) | struct is_swappable : std::true_type {}
type is_nothrow_swappable (line 212) | struct is_nothrow_swappable : std::true_type {}
type swap_adl_tests (line 215) | namespace swap_adl_tests {
type tag (line 218) | struct tag {}
type is_std_swap_noexcept (line 237) | struct is_std_swap_noexcept
type is_std_swap_noexcept<T[N]> (line 243) | struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}
type is_adl_swap_noexcept (line 246) | struct is_adl_swap_noexcept
type is_swappable (line 251) | struct is_swappable
type is_swappable<T[N], T[N]> (line 260) | struct is_swappable<T[N], T[N]>
type is_nothrow_swappable (line 269) | struct is_nothrow_swappable
type voider (line 283) | struct voider { using type = void; }
type is_optional_impl (line 287) | struct is_optional_impl : std::false_type {}
type is_optional_impl<optional<T>> (line 288) | struct is_optional_impl<optional<T>> : std::true_type {}
type returns_void_impl (line 299) | struct returns_void_impl
type optional_storage_base (line 358) | struct optional_storage_base {
method TL_OPTIONAL_11_CONSTEXPR (line 363) | TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
type dummy (line 373) | struct dummy {}
type optional_storage_base<T, true> (line 383) | struct optional_storage_base<T, true> {
type dummy (line 393) | struct dummy {}
type optional_operations_base (line 404) | struct optional_operations_base : optional_storage_base<T> {
method hard_reset (line 407) | void hard_reset() noexcept {
method construct (line 412) | void construct(Args &&... args) noexcept {
method assign (line 417) | void assign(Opt &&rhs) {
method has_value (line 432) | bool has_value() const { return this->m_has_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 434) | TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 435) | TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_v...
method TL_OPTIONAL_11_CONSTEXPR (line 436) | TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_v...
method T (line 438) | constexpr const T &&get() const && { return std::move(this->m_valu...
type optional_copy_base (line 445) | struct optional_copy_base : optional_operations_base<T> {
type optional_copy_base<T, false> (line 451) | struct optional_copy_base<T, false> : optional_operations_base<T> {
method optional_copy_base (line 454) | optional_copy_base() = default;
method optional_copy_base (line 455) | optional_copy_base(const optional_copy_base &rhs) {
method optional_copy_base (line 463) | optional_copy_base(optional_copy_base &&rhs) = default;
method optional_copy_base (line 464) | optional_copy_base &operator=(const optional_copy_base &rhs) = def...
method optional_copy_base (line 465) | optional_copy_base &operator=(optional_copy_base &&rhs) = default;
type optional_move_base (line 475) | struct optional_move_base : optional_copy_base<T> {
type optional_move_base (line 479) | struct optional_move_base
type optional_move_base<T, false> (line 481) | struct optional_move_base<T, false> : optional_copy_base<T> {
method optional_move_base (line 484) | optional_move_base() = default;
method optional_move_base (line 485) | optional_move_base(const optional_move_base &rhs) = default;
method optional_move_base (line 487) | optional_move_base(optional_move_base &&rhs) noexcept(
method optional_move_base (line 495) | optional_move_base &operator=(const optional_move_base &rhs) = def...
method optional_move_base (line 496) | optional_move_base &operator=(optional_move_base &&rhs) = default;
type optional_copy_assign_base (line 503) | struct optional_copy_assign_base : optional_move_base<T> {
type optional_copy_assign_base<T, false> (line 508) | struct optional_copy_assign_base<T, false> : optional_move_base<T> {
method optional_copy_assign_base (line 511) | optional_copy_assign_base() = default;
method optional_copy_assign_base (line 512) | optional_copy_assign_base(const optional_copy_assign_base &rhs) = ...
method optional_copy_assign_base (line 514) | optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
method optional_copy_assign_base (line 515) | optional_copy_assign_base &operator=(const optional_copy_assign_ba...
method optional_copy_assign_base (line 519) | optional_copy_assign_base &
type optional_move_assign_base (line 532) | struct optional_move_assign_base : optional_copy_assign_base<T> {
type optional_move_assign_base (line 536) | struct optional_move_assign_base
type optional_move_assign_base<T, false> (line 540) | struct optional_move_assign_base<T, false> : optional_copy_assign_ba...
method optional_move_assign_base (line 543) | optional_move_assign_base() = default;
method optional_move_assign_base (line 544) | optional_move_assign_base(const optional_move_assign_base &rhs) = ...
method optional_move_assign_base (line 546) | optional_move_assign_base(optional_move_assign_base &&rhs) = default;
method optional_move_assign_base (line 548) | optional_move_assign_base &
method optional_move_assign_base (line 551) | optional_move_assign_base &
type optional_delete_ctor_base (line 564) | struct optional_delete_ctor_base {
method optional_delete_ctor_base (line 565) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 566) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 567) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 568) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 570) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, true, false> (line 574) | struct optional_delete_ctor_base<T, true, false> {
method optional_delete_ctor_base (line 575) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 576) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 577) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 578) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 580) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, true> (line 584) | struct optional_delete_ctor_base<T, false, true> {
method optional_delete_ctor_base (line 585) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 586) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 587) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 588) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 590) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, false> (line 594) | struct optional_delete_ctor_base<T, false, false> {
method optional_delete_ctor_base (line 595) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 596) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 597) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 598) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 600) | optional_delete_ctor_base &
type optional_delete_assign_base (line 611) | struct optional_delete_assign_base {
method optional_delete_assign_base (line 612) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 613) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 614) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 616) | optional_delete_assign_base &
method optional_delete_assign_base (line 618) | optional_delete_assign_base &
type optional_delete_assign_base<T, true, false> (line 622) | struct optional_delete_assign_base<T, true, false> {
method optional_delete_assign_base (line 623) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 624) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 625) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 627) | optional_delete_assign_base &
method optional_delete_assign_base (line 629) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, true> (line 633) | struct optional_delete_assign_base<T, false, true> {
method optional_delete_assign_base (line 634) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 635) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 636) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 638) | optional_delete_assign_base &
method optional_delete_assign_base (line 640) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, false> (line 644) | struct optional_delete_assign_base<T, false, false> {
method optional_delete_assign_base (line 645) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 646) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 647) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 649) | optional_delete_assign_base &
method optional_delete_assign_base (line 651) | optional_delete_assign_base &
class monostate (line 110) | class monostate {}
type in_place_t (line 113) | struct in_place_t {
method in_place_t (line 114) | explicit in_place_t() = default;
class optional (line 120) | class optional
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
type detail (line 122) | namespace detail {
type is_trivially_copy_constructible (line 71) | struct is_trivially_copy_constructible : std::is_trivially_copy_cons...
type is_trivially_copy_constructible<std::vector<T,A>> (line 74) | struct is_trivially_copy_constructible<std::vector<T,A>>
type conjunction (line 136) | struct conjunction : std::true_type {}
type conjunction<B> (line 137) | struct conjunction<B> : B {}
type is_pointer_to_non_const_member_func (line 150) | struct is_pointer_to_non_const_member_func : std::false_type{}
type is_const_or_const_ref (line 164) | struct is_const_or_const_ref : std::false_type{}
type is_const_or_const_ref<T const&> (line 165) | struct is_const_or_const_ref<T const&> : std::true_type{}
type is_const_or_const_ref<T const> (line 166) | struct is_const_or_const_ref<T const> : std::true_type{}
function invoke (line 178) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 186) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 193) | struct invoke_result_impl
type is_swappable (line 210) | struct is_swappable : std::true_type {}
type is_nothrow_swappable (line 212) | struct is_nothrow_swappable : std::true_type {}
type swap_adl_tests (line 215) | namespace swap_adl_tests {
type tag (line 218) | struct tag {}
type is_std_swap_noexcept (line 237) | struct is_std_swap_noexcept
type is_std_swap_noexcept<T[N]> (line 243) | struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}
type is_adl_swap_noexcept (line 246) | struct is_adl_swap_noexcept
type is_swappable (line 251) | struct is_swappable
type is_swappable<T[N], T[N]> (line 260) | struct is_swappable<T[N], T[N]>
type is_nothrow_swappable (line 269) | struct is_nothrow_swappable
type voider (line 283) | struct voider { using type = void; }
type is_optional_impl (line 287) | struct is_optional_impl : std::false_type {}
type is_optional_impl<optional<T>> (line 288) | struct is_optional_impl<optional<T>> : std::true_type {}
type returns_void_impl (line 299) | struct returns_void_impl
type optional_storage_base (line 358) | struct optional_storage_base {
method TL_OPTIONAL_11_CONSTEXPR (line 363) | TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
type dummy (line 373) | struct dummy {}
type optional_storage_base<T, true> (line 383) | struct optional_storage_base<T, true> {
type dummy (line 393) | struct dummy {}
type optional_operations_base (line 404) | struct optional_operations_base : optional_storage_base<T> {
method hard_reset (line 407) | void hard_reset() noexcept {
method construct (line 412) | void construct(Args &&... args) noexcept {
method assign (line 417) | void assign(Opt &&rhs) {
method has_value (line 432) | bool has_value() const { return this->m_has_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 434) | TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 435) | TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_v...
method TL_OPTIONAL_11_CONSTEXPR (line 436) | TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_v...
method T (line 438) | constexpr const T &&get() const && { return std::move(this->m_valu...
type optional_copy_base (line 445) | struct optional_copy_base : optional_operations_base<T> {
type optional_copy_base<T, false> (line 451) | struct optional_copy_base<T, false> : optional_operations_base<T> {
method optional_copy_base (line 454) | optional_copy_base() = default;
method optional_copy_base (line 455) | optional_copy_base(const optional_copy_base &rhs) {
method optional_copy_base (line 463) | optional_copy_base(optional_copy_base &&rhs) = default;
method optional_copy_base (line 464) | optional_copy_base &operator=(const optional_copy_base &rhs) = def...
method optional_copy_base (line 465) | optional_copy_base &operator=(optional_copy_base &&rhs) = default;
type optional_move_base (line 475) | struct optional_move_base : optional_copy_base<T> {
type optional_move_base (line 479) | struct optional_move_base
type optional_move_base<T, false> (line 481) | struct optional_move_base<T, false> : optional_copy_base<T> {
method optional_move_base (line 484) | optional_move_base() = default;
method optional_move_base (line 485) | optional_move_base(const optional_move_base &rhs) = default;
method optional_move_base (line 487) | optional_move_base(optional_move_base &&rhs) noexcept(
method optional_move_base (line 495) | optional_move_base &operator=(const optional_move_base &rhs) = def...
method optional_move_base (line 496) | optional_move_base &operator=(optional_move_base &&rhs) = default;
type optional_copy_assign_base (line 503) | struct optional_copy_assign_base : optional_move_base<T> {
type optional_copy_assign_base<T, false> (line 508) | struct optional_copy_assign_base<T, false> : optional_move_base<T> {
method optional_copy_assign_base (line 511) | optional_copy_assign_base() = default;
method optional_copy_assign_base (line 512) | optional_copy_assign_base(const optional_copy_assign_base &rhs) = ...
method optional_copy_assign_base (line 514) | optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
method optional_copy_assign_base (line 515) | optional_copy_assign_base &operator=(const optional_copy_assign_ba...
method optional_copy_assign_base (line 519) | optional_copy_assign_base &
type optional_move_assign_base (line 532) | struct optional_move_assign_base : optional_copy_assign_base<T> {
type optional_move_assign_base (line 536) | struct optional_move_assign_base
type optional_move_assign_base<T, false> (line 540) | struct optional_move_assign_base<T, false> : optional_copy_assign_ba...
method optional_move_assign_base (line 543) | optional_move_assign_base() = default;
method optional_move_assign_base (line 544) | optional_move_assign_base(const optional_move_assign_base &rhs) = ...
method optional_move_assign_base (line 546) | optional_move_assign_base(optional_move_assign_base &&rhs) = default;
method optional_move_assign_base (line 548) | optional_move_assign_base &
method optional_move_assign_base (line 551) | optional_move_assign_base &
type optional_delete_ctor_base (line 564) | struct optional_delete_ctor_base {
method optional_delete_ctor_base (line 565) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 566) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 567) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 568) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 570) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, true, false> (line 574) | struct optional_delete_ctor_base<T, true, false> {
method optional_delete_ctor_base (line 575) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 576) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 577) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 578) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 580) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, true> (line 584) | struct optional_delete_ctor_base<T, false, true> {
method optional_delete_ctor_base (line 585) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 586) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 587) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 588) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 590) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, false> (line 594) | struct optional_delete_ctor_base<T, false, false> {
method optional_delete_ctor_base (line 595) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 596) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 597) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 598) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 600) | optional_delete_ctor_base &
type optional_delete_assign_base (line 611) | struct optional_delete_assign_base {
method optional_delete_assign_base (line 612) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 613) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 614) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 616) | optional_delete_assign_base &
method optional_delete_assign_base (line 618) | optional_delete_assign_base &
type optional_delete_assign_base<T, true, false> (line 622) | struct optional_delete_assign_base<T, true, false> {
method optional_delete_assign_base (line 623) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 624) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 625) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 627) | optional_delete_assign_base &
method optional_delete_assign_base (line 629) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, true> (line 633) | struct optional_delete_assign_base<T, false, true> {
method optional_delete_assign_base (line 634) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 635) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 636) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 638) | optional_delete_assign_base &
method optional_delete_assign_base (line 640) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, false> (line 644) | struct optional_delete_assign_base<T, false, false> {
method optional_delete_assign_base (line 645) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 646) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 647) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 649) | optional_delete_assign_base &
method optional_delete_assign_base (line 651) | optional_delete_assign_base &
type nullopt_t (line 658) | struct nullopt_t {
type do_not_use (line 659) | struct do_not_use {}
method nullopt_t (line 660) | constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {}
class bad_optional_access (line 666) | class bad_optional_access : public std::exception {
method bad_optional_access (line 668) | bad_optional_access() = default;
class optional (line 679) | class optional : private detail::optional_move_assign_base<T>,
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1090) | constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)...
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1096) | optional(const optional<U> &rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1105) | explicit optional(const optional<U> &rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1115) | optional(optional<U> &&rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1124) | explicit optional(optional<U> &&rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1136) | optional &operator=(nullopt_t) noexcept {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1160) | optional &operator=(U &&u) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1176) | optional &operator=(const optional<U> &rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function optional (line 1198) | optional &operator=(optional<U> &&rhs) {
method and_then (line 698) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 707) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 716) | constexpr auto and_then(F &&f) const & {
method and_then (line 726) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 739) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 749) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 759) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 770) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 784) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 788) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 792) | constexpr auto map(F &&f) const & {
method map (line 796) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 802) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 809) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 816) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 824) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method transform (line 835) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 839) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 843) | constexpr auto transform(F&& f) const & {
method transform (line 847) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 853) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method transform (line 867) | constexpr decltype(optional_map_impl(std::declval<const optional&>(),
method transform (line 875) | constexpr decltype(optional_map_impl(std::declval<const optional&&>(),
method or_else (line 899) | optional<T> or_else(F &&f) && {
method or_else (line 913) | optional<T> or_else(F &&f) const & {
method or_else (line 928) | optional<T> or_else(F &&f) const && {
method or_else (line 937) | optional<T> or_else(F &&f) const && {
method U (line 943) | U map_or(F &&f, U &&u) & {
method U (line 948) | U map_or(F &&f, U &&u) && {
method U (line 953) | U map_or(F &&f, U &&u) const & {
method U (line 959) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 968) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 974) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 980) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 987) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 995) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1001) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1005) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1009) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1014) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1019) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1023) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1027) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1032) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1038) | optional take() {
method optional (line 1047) | constexpr optional() noexcept = default;
method optional (line 1049) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1055) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1061) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1065) | constexpr explicit optional(
function T (line 1216) | T &emplace(Args &&... args) {
function emplace (line 1226) | detail::enable_if_t<
function swap (line 1241) | void
function T (line 1260) | constexpr const T *operator->() const {
function TL_OPTIONAL_11_CONSTEXPR (line 1264) | TL_OPTIONAL_11_CONSTEXPR T *operator->() {
function TL_OPTIONAL_11_CONSTEXPR (line 1269) | TL_OPTIONAL_11_CONSTEXPR T &operator*() & { return this->m_value; }
function T (line 1271) | constexpr const T &operator*() const & { return this->m_value; }
function TL_OPTIONAL_11_CONSTEXPR (line 1273) | TL_OPTIONAL_11_CONSTEXPR T &&operator*() && {
function T (line 1278) | constexpr const T &&operator*() const && { return std::move(this->m_va...
function has_value (line 1282) | constexpr bool has_value() const noexcept { return this->m_has_value; }
function TL_OPTIONAL_11_CONSTEXPR (line 1289) | TL_OPTIONAL_11_CONSTEXPR T &value() & {
function TL_OPTIONAL_11_CONSTEXPR (line 1294) | TL_OPTIONAL_11_CONSTEXPR const T &value() const & {
function TL_OPTIONAL_11_CONSTEXPR (line 1299) | TL_OPTIONAL_11_CONSTEXPR T &&value() && {
function TL_OPTIONAL_11_CONSTEXPR (line 1306) | TL_OPTIONAL_11_CONSTEXPR const T &&value() const && {
function T (line 1314) | constexpr T value_or(U &&u) const & {
function TL_OPTIONAL_11_CONSTEXPR (line 1321) | TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && {
function reset (line 1329) | void reset() noexcept {
type conjunction<B, Bs...> (line 139) | struct conjunction<B, Bs...>
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...)> (line 152) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)> : std::...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&> (line 154) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&> : std:...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&&> (line 156) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&&> : std...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile> (line 158) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&> (line 160) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&&> (line 162) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile...
type invoke_result_impl<
F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
Us...> (line 196) | struct invoke_result_impl<
type returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...> (line 301) | struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...>
function swap (line 1474) | void swap(optional<T> &lhs,
type detail (line 1479) | namespace detail {
type i_am_secret (line 1480) | struct i_am_secret {}
function optional_map_impl (line 1512) | constexpr auto optional_map_impl(Opt &&opt, F &&f) {
function optional_map_impl (line 1522) | auto optional_map_impl(Opt &&opt, F &&f) {
function optional_map_impl (line 1536) | constexpr auto optional_map_impl(Opt &&opt, F &&f) -> optional<Ret> {
function optional_map_impl (line 1547) | auto optional_map_impl(Opt &&opt, F &&f) -> optional<monostate> {
function make_optional (line 1487) | inline constexpr optional<Ret> make_optional(U &&v) {
function make_optional (line 1492) | inline constexpr optional<T> make_optional(Args &&... args) {
function make_optional (line 1496) | inline constexpr optional<T> make_optional(std::initializer_list<U> il,
type detail (line 1506) | namespace detail {
type i_am_secret (line 1480) | struct i_am_secret {}
function optional_map_impl (line 1512) | constexpr auto optional_map_impl(Opt &&opt, F &&f) {
function optional_map_impl (line 1522) | auto optional_map_impl(Opt &&opt, F &&f) {
function optional_map_impl (line 1536) | constexpr auto optional_map_impl(Opt &&opt, F &&f) -> optional<Ret> {
function optional_map_impl (line 1547) | auto optional_map_impl(Opt &&opt, F &&f) -> optional<monostate> {
class optional<T &> (line 1560) | class optional<T &> {
method and_then (line 1571) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 1580) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 1589) | constexpr auto and_then(F &&f) const & {
method and_then (line 1599) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1612) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&...
method TL_OPTIONAL_11_CONSTEXPR (line 1622) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&...
method and_then (line 1632) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const & {
method and_then (line 1643) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const ...
method map (line 1657) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 1661) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 1665) | constexpr auto map(F &&f) const & {
method map (line 1669) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1675) | TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declv...
method TL_OPTIONAL_11_CONSTEXPR (line 1682) | TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declv...
method map (line 1689) | constexpr decltype(detail::optional_map_impl(std::declval<const option...
method map (line 1697) | constexpr decltype(detail::optional_map_impl(std::declval<const option...
method transform (line 1708) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) & {
method transform (line 1712) | TL_OPTIONAL_11_CONSTEXPR auto transform(F&& f) && {
method transform (line 1716) | constexpr auto transform(F&& f) const & {
method transform (line 1720) | constexpr auto transform(F&& f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1726) | TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declv...
method TL_OPTIONAL_11_CONSTEXPR (line 1735) | TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declv...
method transform (line 1742) | constexpr decltype(detail::optional_map_impl(std::declval<const option...
method transform (line 1750) | constexpr decltype(detail::optional_map_impl(std::declval<const option...
method or_else (line 1774) | optional<T> or_else(F &&f) && {
method or_else (line 1788) | optional<T> or_else(F &&f) const & {
method or_else (line 1803) | optional<T> or_else(F &&f) const && {
method or_else (line 1812) | optional<T> or_else(F &&f) const && {
method U (line 1818) | U map_or(F &&f, U &&u) & {
method U (line 1823) | U map_or(F &&f, U &&u) && {
method U (line 1828) | U map_or(F &&f, U &&u) const & {
method U (line 1834) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1843) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1849) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1855) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1862) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1870) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) co...
method TL_OPTIONAL_11_CONSTEXPR (line 1876) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1880) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1884) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1889) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1894) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1898) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1902) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1907) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1913) | optional take() {
method optional (line 1922) | constexpr optional() noexcept : m_value(nullptr) {}
method optional (line 1924) | constexpr optional(nullopt_t) noexcept : m_value(nullptr) {}
method TL_OPTIONAL_11_CONSTEXPR (line 1930) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) noexcept = defa...
method TL_OPTIONAL_11_CONSTEXPR (line 1936) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1942) | constexpr optional(U &&u) noexcept : m_value(std::addressof(u)) {
method optional (line 1947) | constexpr explicit optional(const optional<U> &rhs) noexcept : optiona...
method optional (line 1955) | optional &operator=(nullopt_t) noexcept {
method optional (line 1964) | optional &operator=(const optional &rhs) = default;
method optional (line 1970) | optional &operator=(U &&u) {
method optional (line 1980) | optional &operator=(const optional<U> &rhs) noexcept {
method optional (line 1989) | optional &emplace(U &&u) noexcept {
method swap (line 1993) | void swap(optional &rhs) noexcept { std::swap(m_value, rhs.m_value); }
method T (line 1996) | constexpr const T *operator->() const noexcept { return m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 1998) | TL_OPTIONAL_11_CONSTEXPR T *operator->() noexcept { return m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 2001) | TL_OPTIONAL_11_CONSTEXPR T &operator*() noexcept { return *m_value; }
method T (line 2003) | constexpr const T &operator*() const noexcept { return *m_value; }
method has_value (line 2005) | constexpr bool has_value() const noexcept { return m_value != nullptr; }
method TL_OPTIONAL_11_CONSTEXPR (line 2012) | TL_OPTIONAL_11_CONSTEXPR T &value() {
method TL_OPTIONAL_11_CONSTEXPR (line 2017) | TL_OPTIONAL_11_CONSTEXPR const T &value() const {
method T (line 2024) | constexpr T value_or(U &&u) const & noexcept {
method TL_OPTIONAL_11_CONSTEXPR (line 2032) | TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && noexcept {
method reset (line 2040) | void reset() noexcept { m_value = nullptr; }
type std (line 2050) | namespace std {
type hash<tl::optional<T>> (line 2052) | struct hash<tl::optional<T>> {
FILE: Externals/partio/Partio.h
type ParticleIndex (line 55) | typedef uint64_t ParticleIndex;
function class (line 66) | class ParticlesInfo
FILE: Externals/partio/PartioAttribute.h
function namespace (line 44) | namespace Partio{
function TypeSize (line 74) | inline
function class (line 96) | class ParticleAttribute
function class (line 123) | class FixedAttribute
FILE: Externals/partio/PartioIterator.h
function namespace (line 43) | namespace Partio{
function addAccessor (line 199) | void addAccessor(ParticleAccessor& newAccessor)
FILE: Externals/partio/PartioVec3.h
function namespace (line 42) | namespace Partio{
FILE: Externals/partio/core/KdTree.h
function namespace (line 43) | namespace Partio
function buildHeap (line 139) | inline float buildHeap(uint64_t *result, float *distance_squared,int hea...
function insertToHeap (line 166) | inline float insertToHeap(uint64_t *result,float*distance_squared,int he...
type NearestQuery (line 194) | struct NearestQuery
function id (line 217) | uint64_t id(int i) const { return _ids[i]; }
type ComparePointsById (line 229) | struct ComparePointsById {
function ComputeSubtreeSizes (line 238) | static inline void ComputeSubtreeSizes(int size, int& left, int& right)
type Point (line 261) | struct Point { float p[k]; }
FILE: Externals/partio/core/Mutex.h
function namespace (line 43) | namespace Partio
function namespace (line 107) | namespace Partio{
FILE: Externals/partio/core/Particle.cpp
type Partio (line 50) | namespace Partio{
function TypeName (line 52) | std::string
function ParticlesDataMutable (line 65) | ParticlesDataMutable*
function ParticlesDataMutable (line 71) | ParticlesDataMutable*
function ParticlesDataMutable (line 78) | ParticlesDataMutable*
function ParticlesDataMutable (line 98) | ParticlesDataMutable*
function printAttr (line 160) | void
function getAttrs (line 168) | std::vector<ParticleAttribute>
function print (line 178) | void
function hash (line 233) | double hash(int n, double* args)
type IdAndIndex (line 286) | struct IdAndIndex {
method IdAndIndex (line 287) | IdAndIndex(int id, int index) : _id(id), _index(index) {}
function T (line 294) | T smoothstep(T t){return (3.-2.*t)*t*t;}
function addClusterAttribute (line 296) | void addClusterAttribute(ParticlesDataMutable* cluster, ParticleAttrib...
function ParticlesDataMutable (line 330) | ParticlesDataMutable*
type AttributePair (line 434) | struct AttributePair {
function merge (line 439) | void merge(ParticlesDataMutable& base, const ParticlesData& delta, con...
FILE: Externals/partio/core/ParticleCaching.cpp
type Partio (line 41) | namespace Partio{
function ParticlesData (line 52) | ParticlesData* readCached(const char* filename,const bool sort,const b...
function freeCached (line 74) | void freeCached(ParticlesData* particles)
function beginCachedAccess (line 102) | void beginCachedAccess(ParticlesData*)
function endCachedAccess (line 107) | void endCachedAccess(ParticlesData*)
FILE: Externals/partio/core/ParticleCaching.h
function namespace (line 39) | namespace Partio{
FILE: Externals/partio/core/ParticleHeaders.cpp
function ParticleAttribute (line 188) | ParticleAttribute ParticleHeaders::
function FixedAttribute (line 202) | FixedAttribute ParticleHeaders::
function ParticleIndex (line 216) | ParticleIndex ParticleHeaders::
FILE: Externals/partio/core/ParticleHeaders.h
function namespace (line 39) | namespace Partio{
FILE: Externals/partio/core/ParticleSimple.cpp
function ParticleAttribute (line 210) | ParticleAttribute ParticlesSimple::
function FixedAttribute (line 236) | FixedAttribute ParticlesSimple::
function ParticleIndex (line 260) | ParticleIndex ParticlesSimple::
FILE: Externals/partio/core/ParticleSimple.h
function namespace (line 42) | namespace Partio{
FILE: Externals/partio/core/ParticleSimpleInterleave.cpp
function ParticleAttribute (line 200) | ParticleAttribute ParticlesSimpleInterleave::
function FixedAttribute (line 238) | FixedAttribute ParticlesSimpleInterleave::
function ParticleIndex (line 276) | ParticleIndex ParticlesSimpleInterleave::
FILE: Externals/partio/core/ParticleSimpleInterleave.h
function namespace (line 44) | namespace Partio{
FILE: Externals/partio/io/BGEO.cpp
type Partio (line 49) | namespace Partio
function writeHoudiniStr (line 54) | void writeHoudiniStr(ostream& ostream,const string& s)
type Helper (line 61) | struct Helper
type Helper<ParticleAttribute> (line 67) | struct Helper<ParticleAttribute>
method ParticleAttribute (line 69) | ParticleAttribute addAttribute(ParticlesDataMutable* simple, const c...
method registerIndexedStr (line 70) | int registerIndexedStr(ParticlesDataMutable* simple, const ParticleA...
type Helper<FixedAttribute> (line 73) | struct Helper<FixedAttribute>
method FixedAttribute (line 75) | FixedAttribute addAttribute(ParticlesDataMutable* simple, const char...
method registerIndexedStr (line 76) | int registerIndexedStr(ParticlesDataMutable* simple, const FixedAttr...
class DummyAttribute (line 79) | class DummyAttribute {}
type Helper<DummyAttribute> (line 81) | struct Helper<DummyAttribute>
method DummyAttribute (line 83) | DummyAttribute addAttribute(ParticlesDataMutable* simple, const char...
method registerIndexedStr (line 84) | int registerIndexedStr(ParticlesDataMutable* simple, const DummyAttr...
type DummyAccessor (line 86) | struct DummyAccessor{
method DummyAccessor (line 88) | DummyAccessor(const T& /*attr*/){}
function getAttributes (line 92) | bool getAttributes(int& particleSize, vector<int>& attrOffsets, vector...
function skip (line 157) | void skip(istream *input, size_t numChars)
function skipPrimitives (line 169) | bool skipPrimitives(int nPoints, int nPrims, int nPrimAttrib, istream*...
function ParticlesDataMutable (line 196) | ParticlesDataMutable* readBGEO(const char* filename,const bool headers...
function writeBGEO (line 311) | bool writeBGEO(const char* filename,const ParticlesData& p,const bool ...
FILE: Externals/partio/io/BIN.cpp
type Partio (line 51) | namespace Partio{
function ParticlesDataMutable (line 93) | ParticlesDataMutable* readBIN(const char* filename, const bool headers...
function writeBIN (line 278) | bool writeBIN(const char* filename,const ParticlesData& p,const bool /...
FILE: Externals/partio/io/GEO.cpp
type Partio (line 47) | namespace Partio
function readGeoAttr (line 53) | void readGeoAttr(istream& f,const ParticleAttribute& attr,ParticleAcce...
function writeString (line 63) | void writeString(std::ostream& output,const char* s){
function string (line 74) | string scanString(istream& input)
function ParticlesDataMutable (line 110) | ParticlesDataMutable* readGEO(const char* filename,const bool headersO...
function writeType (line 228) | void writeType(ostream& output,const ParticlesData&,const ParticleAttr...
function writeGEO (line 238) | bool writeGEO(const char* filename,const ParticlesData& p,const bool c...
FILE: Externals/partio/io/MC.cpp
type Partio (line 51) | namespace Partio
function GetString (line 59) | std::string GetString(std::istream& input, unsigned int size){
function ReadAttrHeader (line 81) | bool ReadAttrHeader(std::istream& input, Attribute_Header& attribute){
function CharArrayLen (line 106) | int CharArrayLen(char** charArray){
function IsStringInCharArray (line 116) | bool IsStringInCharArray(std::string target, char** list){
function ParticlesDataMutable (line 132) | ParticlesDataMutable* readMC(const char* filename, const bool headersO...
FILE: Externals/partio/io/PDA.cpp
type Partio (line 45) | namespace Partio
function ParticlesDataMutable (line 52) | ParticlesDataMutable* readPDA(const char* filename,const bool headersO...
function writePDA (line 144) | bool writePDA(const char* filename,const ParticlesData& p,const bool c...
FILE: Externals/partio/io/PDB.cpp
type PDB (line 40) | namespace PDB{
type Partio (line 52) | namespace Partio
type PDB_POLICY (line 57) | struct PDB_POLICY
type PDB_POLICY<32> (line 58) | struct PDB_POLICY<32>
type PDB_POLICY<64> (line 66) | struct PDB_POLICY<64>
function string (line 75) | string GetString(istream& input,bool& error)
function ParticlesDataMutable (line 92) | ParticlesDataMutable* readPDBHelper(const char* filename,const bool he...
function writePDBHelper (line 176) | bool writePDBHelper(const char* filename,const ParticlesData& p,const ...
function ParticlesDataMutable (line 254) | ParticlesDataMutable* readPDB32(const char* filename,const bool header...
function ParticlesDataMutable (line 257) | ParticlesDataMutable* readPDB64(const char* filename,const bool header...
function writePDB32 (line 260) | bool writePDB32(const char* filename,const ParticlesData& p,const bool...
Condensed preview — 183 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,334K chars).
[
{
"path": ".clang-format",
"chars": 10410,
"preview": "Language: Cpp # Maybe change\nStandard: Auto #"
},
{
"path": ".clang-tidy",
"chars": 52822,
"preview": "# abseil-cleanup-ctad Avoid doubled printing of type\n# abseil-duration-addition"
},
{
"path": ".gitignore",
"chars": 127,
"preview": ".vscode\nbuild\nclang-format-all.bat\nclang-tidy-all.bat\nfix_compilation_database.py\n**/*.so\n**/*.exe.manifest\n**/*.exe\n**/"
},
{
"path": ".gitmodules",
"chars": 78,
"preview": "[submodule \"Data\"]\n\tpath = Data\n\turl = https://github.com/littlemine/Data.git\n"
},
{
"path": "CMake/DownloadProject.CMakeLists.cmake.in",
"chars": 501,
"preview": "cmake_minimum_required(VERSION 2.8.2)\n\nproject(${DL_ARGS_PROJ}-download NONE)\n\ninclude(ExternalProject)\nExternalProject_"
},
{
"path": "CMake/DownloadProject.LICENSE",
"chars": 1075,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2015 Crascit\n\nPermission is hereby granted, free of charge, to any person obtaining"
},
{
"path": "CMake/DownloadProject.cmake",
"chars": 5872,
"preview": "# MODULE: DownloadProject\n#\n# PROVIDES:\n# download_project( PROJ projectName\n# [PREFIX prefixDir]"
},
{
"path": "CMake/FindWayland.cmake",
"chars": 3293,
"preview": "# Try to find Wayland on a Unix system\n#\n# This will define:\n#\n# WAYLAND_FOUND - True if Wayland is found\n# WA"
},
{
"path": "CMake/FindXCB.cmake",
"chars": 1304,
"preview": "# - FindXCB\n#\n# Copyright 2015 Valve Coporation\n\nfind_package(PkgConfig)\n\nif(NOT XCB_FIND_COMPONENTS)\n set(XCB_FIND_C"
},
{
"path": "CMake-Utils/setup_cpp.cmake",
"chars": 1377,
"preview": "function(add_cpp_executable binary)\n\tadd_executable(${binary} ${ARGN})\n\t\n\ttarget_compile_options(${binary} \n\t\tINTERFACE "
},
{
"path": "CMake-Utils/setup_cuda.cmake",
"chars": 3251,
"preview": "message(\"## setup cuda\")\n\n#Find CUDA\ninclude(CheckLanguage)\ncheck_language(CUDA)\n\nif(CMAKE_CUDA_COMPILER)\n\tenable_langua"
},
{
"path": "CMake-Utils/setup_externallibs.cmake",
"chars": 2076,
"preview": "#####\nset(CPM_DOWNLOAD_LOCATION \"${CMAKE_BINARY_DIR}/cmake/CPM.cmake\")\nset(CPM_DOWNLOAD_VERSION 0.38.1)\n\nif(NOT (EXISTS "
},
{
"path": "CMake-Utils/setup_python.cmake",
"chars": 810,
"preview": "function(add_python_library library)\n add_library(${library} MODULE ${ARGN})\n target_compile_options(${library} \n I"
},
{
"path": "CMakeLists.txt",
"chars": 983,
"preview": "cmake_minimum_required(VERSION 3.15) # support relative path\n\nmessage(\"=============================================="
},
{
"path": "Externals/CMakeLists.txt",
"chars": 869,
"preview": "find_package(Git)\ninclude(FetchContent)\ninclude(ExternalProject)\ninclude(DownloadProject)\n\n# partio\nmessage(\"## building"
},
{
"path": "Externals/SDFGen/CMakeLists.txt",
"chars": 1258,
"preview": "cmake_minimum_required(VERSION 2.6)\nProject(\"SDFGen\")\n\n# Set the build type. Options are:\n# Coverage : w/ debug "
},
{
"path": "Externals/SDFGen/README.md",
"chars": 1256,
"preview": "# SDFGen\nA simple commandline utility to generate grid-based signed distance field (level set) generator from triangle m"
},
{
"path": "Externals/SDFGen/array1.h",
"chars": 19662,
"preview": "#ifndef ARRAY1_H\n#define ARRAY1_H\n\n#include <algorithm>\n#include <cstring>\n#include <cassert>\n#include <climits>\n#includ"
},
{
"path": "Externals/SDFGen/array2.h",
"chars": 6931,
"preview": "#ifndef ARRAY2_H\n#define ARRAY2_H\n\n#include \"array1.h\"\n#include <algorithm>\n#include <cassert>\n#include <vector>\n\ntempla"
},
{
"path": "Externals/SDFGen/array3.h",
"chars": 6590,
"preview": "#ifndef ARRAY3_H\n#define ARRAY3_H\n\n#include \"array1.h\"\n#include <algorithm>\n#include <cassert>\n#include <vector>\n\ntempla"
},
{
"path": "Externals/SDFGen/config.h.in",
"chars": 166,
"preview": "#ifndef SDFGEN_CONFIG_H\n#define SDFGEN_CONFIG_H\n\n/*\n * Configuration Header for SDFGEN\n */\n \n/// Configured libraries\n#c"
},
{
"path": "Externals/SDFGen/hashgrid.h",
"chars": 4446,
"preview": "#ifndef HASHGRID_H\n#define HASHGRID_H\n\n#include \"hashtable.h\"\n#include \"vec.h\"\n\n//======================================"
},
{
"path": "Externals/SDFGen/hashtable.h",
"chars": 6954,
"preview": "#ifndef HASHTABLE_H\n#define HASHTABLE_H\n\n#include <functional>\n#include <iostream>\n#include <vector>\n\ntemplate<class Key"
},
{
"path": "Externals/SDFGen/main.cpp",
"chars": 6580,
"preview": "//SDFGen - A simple grid-based signed distance field (level set) generator for triangle meshes.\n//Written by Christopher"
},
{
"path": "Externals/SDFGen/makelevelset3.cpp",
"chars": 8340,
"preview": "#include \"makelevelset3.h\"\n\n// find distance x0 is from segment x1-x2\nstatic float point_segment_distance(const Vec3f &x"
},
{
"path": "Externals/SDFGen/makelevelset3.h",
"chars": 701,
"preview": "#ifndef MAKELEVELSET3_H\n#define MAKELEVELSET3_H\n\n#include \"array3.h\"\n#include \"vec.h\"\n\n// tri is a list of triangles in "
},
{
"path": "Externals/SDFGen/util.h",
"chars": 10469,
"preview": "#ifndef UTIL_H\n#define UTIL_H\n\n#include <algorithm>\n#include <vector>\n#include <cmath>\n#include <iostream>\n\n#ifndef M_PI"
},
{
"path": "Externals/SDFGen/vec.h",
"chars": 11779,
"preview": "#ifndef VEC_H\n#define VEC_H\n\n#include <cassert>\n#include <cmath>\n#include <iostream>\n#include \"util.h\"\n\n// Defines a thi"
},
{
"path": "Externals/function_ref/tl/function_ref.hpp",
"chars": 7267,
"preview": "///\n// function_ref - A low-overhead non-owning function\n// Written in 2017 by Simon Brand (@TartanLlama)\n//\n// To the e"
},
{
"path": "Externals/optional/tl/optional.hpp",
"chars": 73553,
"preview": "\n///\n// optional - An implementation of std::optional with extensions\n// Written in 2017 by Simon Brand (simonrbrand@gma"
},
{
"path": "Externals/partio/CMakeLists.txt",
"chars": 3313,
"preview": "# PARTIO SOFTWARE\n# Copyright 2010 Disney Enterprises, Inc. All rights reserved\n# \n# Redistribution and use in source an"
},
{
"path": "Externals/partio/Partio.h",
"chars": 15237,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/PartioAttribute.h",
"chars": 5017,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/PartioIterator.h",
"chars": 6846,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/PartioVec3.h",
"chars": 3113,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/KdTree.h",
"chars": 14609,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/Mutex.h",
"chars": 3384,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/Particle.cpp",
"chars": 22866,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/ParticleCaching.cpp",
"chars": 3639,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/ParticleCaching.h",
"chars": 1782,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/ParticleHeaders.cpp",
"chars": 6804,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/ParticleHeaders.h",
"chars": 4914,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/ParticleSimple.cpp",
"chars": 15356,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/ParticleSimple.h",
"chars": 5987,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/ParticleSimpleInterleave.cpp",
"chars": 14850,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/core/ParticleSimpleInterleave.h",
"chars": 6069,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/BGEO.cpp",
"chars": 18652,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/BIN.cpp",
"chars": 20990,
"preview": "/*\nPARTIO SOFTWARE\nCopyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved\n\nRedistribution an"
},
{
"path": "Externals/partio/io/GEO.cpp",
"chars": 11926,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/MC.cpp",
"chars": 11444,
"preview": "/*\nPARTIO SOFTWARE\nCopyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved\n\nRedistribution an"
},
{
"path": "Externals/partio/io/PDA.cpp",
"chars": 6677,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2011 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/PDB.cpp",
"chars": 10803,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/PDC.cpp",
"chars": 5968,
"preview": "/*\nPARTIO SOFTWARE\nCopyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved\n\n keypress events "
},
{
"path": "Externals/partio/io/PRT.cppbak",
"chars": 16622,
"preview": "/*\nPARTIO SOFTWARE\nCopyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved\n\nRedistribution an"
},
{
"path": "Externals/partio/io/PTC.cpp",
"chars": 13128,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/PTS.cpp",
"chars": 9593,
"preview": "/*\nPARTIO SOFTWARE\nCopyright (c) 2011 Disney Enterprises, Inc. and Contributors, All rights reserved\n\nRedistribution an"
},
{
"path": "Externals/partio/io/ParticleIO.cpp",
"chars": 6080,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/PartioEndian.h",
"chars": 4362,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/RIB.cpp",
"chars": 5202,
"preview": "/*\n* Copyright (c) 2010 - 2011 Sebastien Noury <sebastien@soja.org>\n*\n* Permission is hereby granted, free of charge, to"
},
{
"path": "Externals/partio/io/ZIP.cpp",
"chars": 25100,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/ZIP.h",
"chars": 3477,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/half2float.h",
"chars": 854016,
"preview": "{ 0},{0x33800000},{0x34000000},{0x34400000},{0x34800000},{0x34a00000},{0x34c00000},{0x34e00000},{0x35000000},{0x"
},
{
"path": "Externals/partio/io/pdb.h",
"chars": 4746,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2010 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/partio/io/readers.h",
"chars": 4142,
"preview": "/*\nPARTIO SOFTWARE\nCopyright 2011 Disney Enterprises, Inc. All rights reserved\n\nRedistribution and use in source and bin"
},
{
"path": "Externals/variant/mpark/config.hpp",
"chars": 2469,
"preview": "// MPark.Variant\n//\n// Copyright Michael Park, 2015-2017\n//\n// Distributed under the Boost Software License, Version 1.0"
},
{
"path": "Externals/variant/mpark/in_place.hpp",
"chars": 847,
"preview": "// MPark.Variant\n//\n// Copyright Michael Park, 2015-2017\n//\n// Distributed under the Boost Software License, Version 1.0"
},
{
"path": "Externals/variant/mpark/lib.hpp",
"chars": 16251,
"preview": "// MPark.Variant\n//\n// Copyright Michael Park, 2015-2017\n//\n// Distributed under the Boost Software License, Version 1.0"
},
{
"path": "Externals/variant/mpark/variant.hpp",
"chars": 83703,
"preview": "// MPark.Variant\n//\n// Copyright Michael Park, 2015-2017\n//\n// Distributed under the Boost Software License, Version 1.0"
},
{
"path": "LICENSE",
"chars": 1190,
"preview": "MIT License\n\nCopyright (c) 2020 Xinlei Wang, Yuxing Qiu, Stuart R. Slattery, Yu Fang, Minchen Li, Song-Chun Zhu, Yixin Z"
},
{
"path": "Library/CMakeLists.txt",
"chars": 26,
"preview": "add_subdirectory(MnSystem)"
},
{
"path": "Library/MnBase/Algorithm/MappingKernels.cuh",
"chars": 2886,
"preview": "#ifndef MAPPING_KERNELS_CUH\n#define MAPPING_KERNELS_CUH\n#include <driver_types.h>\n\n#define PRINT_FIRST_INDICES 0\n\nnamesp"
},
{
"path": "Library/MnBase/Algorithm/ParallelPatterns.cuh",
"chars": 5254,
"preview": "#ifndef PARALLEL_PATTERNS_CUH\n#define PARALLEL_PATTERNS_CUH\n#include \"MnSystem/Cuda/HostUtils.hpp\"\n#include \"MnSystem/Cu"
},
{
"path": "Library/MnBase/Algorithm/SortKernels.cuh",
"chars": 834,
"preview": "#ifndef SORT_KERNELS_CUH\n#define SORT_KERNELS_CUH\n#include <stdint.h>\n\nnamespace mn {\n\ntemplate<typename ElemType, unsig"
},
{
"path": "Library/MnBase/Concurrency/Concurrency.h",
"chars": 2950,
"preview": "#ifndef CONCURRENCY_H\n#define CONCURRENCY_H\n\n#include <atomic>\n#include <condition_variable>\n#include <future>\n#include "
},
{
"path": "Library/MnBase/DataStructure/Bvh/Bvh.cuh",
"chars": 94,
"preview": "#ifndef BVH_CUH\n#define BVH_CUH\n#include <stdint.h>\n\n#include <tuple>\n\nnamespace mn {}\n\n#endif"
},
{
"path": "Library/MnBase/DataStructure/FSM/FiniteStateMachine.h",
"chars": 777,
"preview": "#ifndef FINITE_STATE_MACHINE_H\n#define FINITE_STATE_MACHINE_H\n#include \"MnBase/Meta/Optional.h\"\n#include \"MnBase/Meta/Po"
},
{
"path": "Library/MnBase/DataStructure/Hash/Hash.cuh",
"chars": 7336,
"preview": "#ifndef HASH_CUH\n#define HASH_CUH\n#include \"MnBase/AggregatedAttribs.cuh\"\n#include \"MnBase/Math/Bit/Bits.h\"\n#include \"Mn"
},
{
"path": "Library/MnBase/Geometry/GeometrySampler.h",
"chars": 967,
"preview": "#ifndef GEOMETRY_SAMPLER_H\n#define GEOMETRY_SAMPLER_H\n#include <array>\n#include <vector>\n\n#include \"MnBase/Math/Vec.h\"\n\n"
},
{
"path": "Library/MnBase/Math/Bit/Bits.h",
"chars": 2757,
"preview": "#ifndef BITS_H\n#define BITS_H\n#include <stdint.h>\n\n#include <bitset>\n#include <limits>\n\nnamespace mn {\n/**\n */\ntemplate<"
},
{
"path": "Library/MnBase/Math/Bit/SpatialEncoder.cuh",
"chars": 4952,
"preview": "#ifndef SPATIAL_ENCODER_CUH\n#define SPATIAL_ENCODER_CUH\n#include <driver_types.h>\n#include <stdint.h>\n\n#include \"MnBase/"
},
{
"path": "Library/MnBase/Math/Matrix/EigenDecomposition.cuh",
"chars": 7411,
"preview": "#ifndef EIGEN_DECOMPOSITION_CUH\n#define EIGEN_DECOMPOSITION_CUH\n\n#include <device_types.h>\n\n#include \"MatrixUtils.h\"\n\nna"
},
{
"path": "Library/MnBase/Math/Matrix/Givens.cuh",
"chars": 7742,
"preview": "/**\nGivens rotation\n*/\n#ifndef GIVENS_CUH\n#define GIVENS_CUH\n#include <type_traits>\n#include <cmath>\n\n#define ENABLE_COL"
},
{
"path": "Library/MnBase/Math/Matrix/MatrixKernels.cuh",
"chars": 714,
"preview": "#ifndef MATRIX_KERNELS_CUH\n#define MATRIX_KERNELS_CUH\n\n#include <device_types.h>\n\n#include \"MnBase/AggregatedAttribs.cuh"
},
{
"path": "Library/MnBase/Math/Matrix/MatrixUtils.h",
"chars": 15184,
"preview": "#ifndef MATRIX_UTILS_H\n#define MATRIX_UTILS_H\n\n#include \"Utility.h\"\n\nnamespace mn {\n\n//TODO: When we have c++20 use std:"
},
{
"path": "Library/MnBase/Math/Matrix/Utility.h",
"chars": 1655,
"preview": "#ifndef MATRIX_UTILITY_H\n#define MATRIX_UTILITY_H\n\nnamespace mn {\n\nnamespace math {\n\ttemplate<typename T>\n\tconstexpr int"
},
{
"path": "Library/MnBase/Math/Matrix/qr.cuh",
"chars": 1930,
"preview": "#ifndef QR_CUH\n#define QR_CUH\n#include \"Givens.cuh\"\n\nnamespace mn {\n\nnamespace math {\n\n\t/**\n\t \\brief 2x2 polar decomposi"
},
{
"path": "Library/MnBase/Math/Matrix/svd.cuh",
"chars": 36687,
"preview": "#ifndef SVD3_CUH\n#define SVD3_CUH\n\n#include <cuda.h>\n\n#include \"Utility.h\"\n#include \"math.h\"// CUDA math library\n#includ"
},
{
"path": "Library/MnBase/Math/Probability/Probability.cpp",
"chars": 1761,
"preview": "#include \"Probability.h\"\n\n#ifdef _WIN32\n#\tifndef M_PI\n#\t\tdefine M_PI 3.14159265358979323846//NOLINT(cppcoreguidelines-ma"
},
{
"path": "Library/MnBase/Math/Probability/Probability.h",
"chars": 549,
"preview": "#ifndef PROBABILITY_H\n#define PROBABILITY_H\n\n#include <functional>\n#include <random>\n\nnamespace mn {\n\nclass Propability "
},
{
"path": "Library/MnBase/Math/Vec.h",
"chars": 20586,
"preview": "#ifndef MN_VEC_H\n#define MN_VEC_H\n#include <array>\n#include <functional>\n#include <type_traits>\n#include <utility>\n\n#inc"
},
{
"path": "Library/MnBase/Memory/Allocator.h",
"chars": 3182,
"preview": "#ifndef ALLOCATOR_H\n#define ALLOCATOR_H\n\n#include <type_traits>\n\n#include \"MemoryResource.h\"\n\nnamespace mn {\n\n/// statel"
},
{
"path": "Library/MnBase/Memory/MemObj.h",
"chars": 407,
"preview": "#ifndef MEM_OBJ_H\n#define MEM_OBJ_H\n\nnamespace mn {\n\nstruct MemBackend {\n\tusing uchar = unsigned char;\n\n\tenum class Phys"
},
{
"path": "Library/MnBase/Memory/MemoryResource.h",
"chars": 1056,
"preview": "#ifndef MEMORY_RESOURCE_H\n#define MEMORY_RESOURCE_H\n#include \"MnBase/Singleton.h\"\n\nnamespace mn {\n\ntemplate<typename der"
},
{
"path": "Library/MnBase/Meta/AllocMeta.cuh",
"chars": 4237,
"preview": "#ifndef ALLOC_META_H\n#define ALLOC_META_H\n\n#include <cuda_runtime_api.h>\n#include <driver_types.h>\n\n#include \"MnSystem/C"
},
{
"path": "Library/MnBase/Meta/ControlFlow.h",
"chars": 775,
"preview": "#ifndef CONTROL_FLOW_H\n#define CONTROL_FLOW_H\n#include <initializer_list>\n\n#include \"Meta.h\"\n\nnamespace mn {\n\n// enable_"
},
{
"path": "Library/MnBase/Meta/Functional.h",
"chars": 1392,
"preview": "#ifndef FUNCTIONAL_H\n#define FUNCTIONAL_H\n\n#include <functional>\n#include <optional>\n\n#include \"Meta.h\"\n#include \"TupleM"
},
{
"path": "Library/MnBase/Meta/MathMeta.h",
"chars": 5675,
"preview": "#ifndef MATH_META_H\n#define MATH_META_H\n\n#include <type_traits>\n#include <utility>\n\n#include \"Meta.h\"\n#include \"MnBase/M"
},
{
"path": "Library/MnBase/Meta/Meta.h",
"chars": 1481,
"preview": "#ifndef META_H\n#define META_H\n\n#include <initializer_list>\n#include <type_traits>\n\nnamespace mn {\n\n/// initializer list "
},
{
"path": "Library/MnBase/Meta/Optional.h",
"chars": 263,
"preview": "#ifndef OPTIONAL_H\n#define OPTIONAL_H\n//#include <mapbox/optional.hpp>\n#include <tl/optional.hpp>\n\nnamespace mn {\n\n// te"
},
{
"path": "Library/MnBase/Meta/PatternMeta.h",
"chars": 556,
"preview": "#ifndef PATTERN_META_H\n#define PATTERN_META_H\n\n#include <initializer_list>\n#include <type_traits>\n\n#include \"TypeMeta.h\""
},
{
"path": "Library/MnBase/Meta/Polymorphism.h",
"chars": 1690,
"preview": "#ifndef POLYMORPHISM_H\n#define POLYMORPHISM_H\n//#include <mapbox/variant.hpp>\n#include <mpark/variant.hpp>\n\n#define ADVA"
},
{
"path": "Library/MnBase/Meta/Relationship.h",
"chars": 472,
"preview": "#ifndef RELATIONSHIP_H\n#define RELATIONSHIP_H\n\n#include \"Meta.h\"\n\nnamespace mn {\n\nstruct wrapper_base {\n\tstatic constexp"
},
{
"path": "Library/MnBase/Meta/TupleMeta.h",
"chars": 9313,
"preview": "#ifndef TUPLE_META_H\n#define TUPLE_META_H\n\n#include <array>\n#include <tuple>\n#include <utility>\n#include <vector>\n\n#incl"
},
{
"path": "Library/MnBase/Meta/TypeDecoration.h",
"chars": 226,
"preview": "#ifndef TYPE_DECORATION_H\n#define TYPE_DECORATION_H\n\n#include \"Meta.h\"\n\nnamespace mn {\n\n/// decay\n/// const, volatile, r"
},
{
"path": "Library/MnBase/Meta/TypeIdentity.h",
"chars": 161,
"preview": "#ifndef TYPE_IDENTITY_H\n#define TYPE_IDENTITY_H\n\n#include \"Meta.h\"\n\nnamespace mn {\n\n/// primary type\nstruct {\n\t;\n};\n\n///"
},
{
"path": "Library/MnBase/Meta/TypeMeta.h",
"chars": 7333,
"preview": "#ifndef TYPE_META_H\n#define TYPE_META_H\n\n#include <tuple>\n#include <type_traits>\n#include <utility>\n\n#include \"MnBase/Re"
},
{
"path": "Library/MnBase/Meta/TypeOperation.h",
"chars": 344,
"preview": "#ifndef TYPE_OPERATION_H\n#define TYPE_OPERATION_H\n\n#include \"Meta.h\"\n\nnamespace mn {\n\ntemplate<typename T, typename = vo"
},
{
"path": "Library/MnBase/Meta/TypeProperty.h",
"chars": 124,
"preview": "#ifndef TYPE_PROPERTY_H\n#define TYPE_PROPERTY_H\n\n#include \"Meta.h\"\n\nnamespace mn {\n\nstruct {\n\t;\n};\n\n}// namespace mn\n\n#e"
},
{
"path": "Library/MnBase/Object/Function.h",
"chars": 561,
"preview": "#ifndef FUNCTION_H\n#define FUNCTION_H\n#include <functional>\n#include <tl/function_ref.hpp>\n#include <tuple>\n\n#include \"M"
},
{
"path": "Library/MnBase/Object/Property.h",
"chars": 1122,
"preview": "#ifndef PROPERTY_H\n#define PROPERTY_H\n\n#include <type_traits>\n\nnamespace mn {\n\nstruct NonCopyable {\n\tNonCopyable()\t\t\t\t\t\t"
},
{
"path": "Library/MnBase/Object/Structural.h",
"chars": 5351,
"preview": "#ifndef STRUCTURAL_H\n#define STRUCTURAL_H\n\n#include <memory>\n#include <type_traits>\n#include <utility>\n\n#include \"Functi"
},
{
"path": "Library/MnBase/Object/StructuralAuxiliary.h",
"chars": 1220,
"preview": "#ifndef STRUCTURAL_AUXILIARY_H\n#define STRUCTURAL_AUXILIARY_H\n#include \"MnBase/Math/Vec.h\"\n#include \"MnBase/Meta/MathMet"
},
{
"path": "Library/MnBase/Object/StructuralDeclaration.h",
"chars": 11960,
"preview": "#ifndef STRUCTURAL_DECLARATION_H\n#define STRUCTURAL_DECLARATION_H\n#include <type_traits>\n\n#include \"MnBase/Math/Vec.h\"\n#"
},
{
"path": "Library/MnBase/Profile/CppTimers.hpp",
"chars": 697,
"preview": "#ifndef CPP_TIMERS_HPP\n#define CPP_TIMERS_HPP\n\n#include <fmt/color.h>\n#include <fmt/core.h>\n\n#include <chrono>\n\nnamespac"
},
{
"path": "Library/MnBase/Profile/CudaTimers.cuh",
"chars": 851,
"preview": "#ifndef CUDA_TIMERS_CUH\n#define CUDA_TIMERS_CUH\n\n#include <cuda_runtime_api.h>\n#include <fmt/color.h>\n#include <fmt/core"
},
{
"path": "Library/MnBase/Reflection.h",
"chars": 435,
"preview": "#ifndef REFLECTION_H\n#define REFLECTION_H\n\n#include <typeinfo>\n\nnamespace mn {\n\n/// compile-time type inspection\ntemplat"
},
{
"path": "Library/MnBase/Singleton.h",
"chars": 1269,
"preview": "#ifndef SINGLETON_H\n#define SINGLETON_H\n\n#include <assert.h>\n// http ://www.boost.org/doc/libs/1_39_0/boost/pool/detail/"
},
{
"path": "Library/MnSystem/CMakeLists.txt",
"chars": 870,
"preview": "include(sourcelist.cmake)\n\n# build: PRIVATE, usage: INTERFACE, both: PUBLIC.\nif (CUDA_FOUND)\n\tadd_cuda_library(mncuda)\n\t"
},
{
"path": "Library/MnSystem/Cuda/Allocators.cuh",
"chars": 7091,
"preview": "#ifndef ALLOCATORS_CUH\n#define ALLOCATORS_CUH\n#include <cuda_runtime_api.h>\n\n#include <iostream>\n#include <memory>\n\n#inc"
},
{
"path": "Library/MnSystem/Cuda/Cuda.cu",
"chars": 8626,
"preview": "#include <cuda_occupancy.h>\t ///<\tfor optimal kernel launching\n#include <cuda_profiler_api.h>///<\tfor evaluating kernel"
},
{
"path": "Library/MnSystem/Cuda/Cuda.h",
"chars": 10787,
"preview": "#ifndef SYSTEM_CUDA_H\n#define SYSTEM_CUDA_H\n\n#include <string>\n//#include <helper_cuda.h>\n#include <driver_types.h>\n\n#in"
},
{
"path": "Library/MnSystem/Cuda/DeviceUtils.cu",
"chars": 261,
"preview": "#include \"DeviceUtils.cuh\"\n\nnamespace mn {\n\ntemplate<int NumPageBits>\n__device__ int retrieve_block_local_offset(int lev"
},
{
"path": "Library/MnSystem/Cuda/DeviceUtils.cuh",
"chars": 6141,
"preview": "#ifndef DEVICE_UTILS_CUH\n#define DEVICE_UTILS_CUH\n\n#include <cooperative_groups.h>\n#include <device_types.h>\n#include <s"
},
{
"path": "Library/MnSystem/Cuda/ExecutionPolicy.h",
"chars": 2242,
"preview": "#ifndef CUDA_EXECUTION_POLICY_H\n#define CUDA_EXECUTION_POLICY_H\n#include <driver_types.h>\n\n#include <string>\n\nnamespace "
},
{
"path": "Library/MnSystem/Cuda/HostUtils.hpp",
"chars": 3014,
"preview": "#ifndef HOST_UTILS_HPP\n#define HOST_UTILS_HPP\n\n#include <thrust/device_ptr.h>\n#include <thrust/device_vector.h>\n\n#includ"
},
{
"path": "Library/MnSystem/Cuda/KernelLauncher.cuh",
"chars": 2716,
"preview": "#ifndef KERNEL_LAUNCHER_CUH\n#define KERNEL_LAUNCHER_CUH\n\n#include \"ExecutionPolicy.h\"\n#include \"MnUtility/Profiler/Perfo"
},
{
"path": "Library/MnSystem/Cuda/MemoryUtils.cu",
"chars": 76,
"preview": "#include \"Cuda.h\"\n#include \"MemoryUtils.cuh\"\n\nnamespace mn {}// namespace mn"
},
{
"path": "Library/MnSystem/Cuda/MemoryUtils.cuh",
"chars": 115,
"preview": "#ifndef MEMORY_UTILS_CUH\n#define MEMORY_UTILS_CUH\n#include \"Allocators.cuh\"\n\nnamespace mn {}// namespace mn\n\n#endif"
},
{
"path": "Library/MnSystem/IO/IO.cpp",
"chars": 379,
"preview": "#include \"IO.h\"\n//#include <filesystem>\n//#include <compare>\n//#include <iostream>\n\nnamespace mn {\n\n/*\nvoid f()\n{\n doub"
},
{
"path": "Library/MnSystem/IO/IO.h",
"chars": 1245,
"preview": "#ifndef IO_H\n#define IO_H\n#include <tl/function_ref.hpp>\n\n#include \"MnBase/Concurrency/Concurrency.h\"\n#include \"MnBase/S"
},
{
"path": "Library/MnSystem/IO/ParticleIO.hpp",
"chars": 3632,
"preview": "#ifndef __PARTICLE_IO_HPP_\n#define __PARTICLE_IO_HPP_\n#include <Partio.h>\n\n#include <array>\n#include <string>\n#include <"
},
{
"path": "Library/MnSystem/IO/PoissonDisk/PoissonDisk.h",
"chars": 3064,
"preview": "#include <fstream>\n#include <iostream>\n#include <string>\n#include <vector>\n\n#include \"cyPoint.h\"\n#include \"cySampleElim."
},
{
"path": "Library/MnSystem/IO/PoissonDisk/SampleGenerator.h",
"chars": 14742,
"preview": "#if 1\n#\tinclude <time.h>\n\n#\tinclude <ctime>\n#\tinclude <fstream>\n#\tinclude <iostream>\n#\tinclude <string>\n#\tinclude <vecto"
},
{
"path": "Library/MnSystem/IO/PoissonDisk/cyCore.h",
"chars": 8332,
"preview": "// cyCodeBase by Cem Yuksel\n// [www.cemyuksel.com]\n//-------------------------------------------------------------------"
},
{
"path": "Library/MnSystem/IO/PoissonDisk/cyHeap.h",
"chars": 10917,
"preview": "// cyCodeBase by Cem Yuksel\n// [www.cemyuksel.com]\n//-------------------------------------------------------------------"
},
{
"path": "Library/MnSystem/IO/PoissonDisk/cyPoint.h",
"chars": 32745,
"preview": "// cyCodeBase by Cem Yuksel\n// [www.cemyuksel.com]\n//-------------------------------------------------------------------"
},
{
"path": "Library/MnSystem/IO/PoissonDisk/cyPointCloud.h",
"chars": 19690,
"preview": "// cyCodeBase by Cem Yuksel\n// [www.cemyuksel.com]\n//-------------------------------------------------------------------"
},
{
"path": "Library/MnSystem/IO/PoissonDisk/cySampleElim.h",
"chars": 18454,
"preview": "// cyCodeBase by Cem Yuksel\n// [www.cemyuksel.com]\n//-------------------------------------------------------------------"
},
{
"path": "Library/MnSystem/sourcelist.cmake",
"chars": 192,
"preview": "set(CudaSystemSrc\n\t${PROJECT_SOURCE_DIR}/Library/MnSystem/Cuda/Cuda.cu\n\t${PROJECT_SOURCE_DIR}/Library/MnSystem/Cuda/Devi"
},
{
"path": "Projects/CMakeLists.txt",
"chars": 737,
"preview": "# borrowed from taichi\nfile(GLOB children RELATIVE ${CMAKE_CURRENT_LIST_DIR} *)\n\nforeach(dir ${children})\n if(IS_DIRE"
},
{
"path": "Projects/GMPM/CMakeLists.txt",
"chars": 1023,
"preview": "if (CUDA_FOUND)\n\tadd_cuda_executable(gmpm)\n\t\n\ttarget_sources(gmpm\n\t\tPRIVATE gmpm.cu\n\t)\n\t\n\ttarget_link_libraries(gmpm"
},
{
"path": "Projects/GMPM/constitutive_models.cuh",
"chars": 14906,
"preview": "#ifndef CONSTITUTIVE_MODELS_CUH\n#define CONSTITUTIVE_MODELS_CUH\n#include <MnBase/Math/Matrix/MatrixUtils.h>\n#include <Mn"
},
{
"path": "Projects/GMPM/gmpm.cu",
"chars": 7661,
"preview": "#include <MnBase/Geometry/GeometrySampler.h>\n#include <MnBase/Math/Vec.h>\n#include <MnSystem/Cuda/Cuda.h>\n#include <MnSy"
},
{
"path": "Projects/GMPM/gmpm_simulator.cuh",
"chars": 36078,
"preview": "#ifndef GMPM_SIMULATOR_CUH\n#define GMPM_SIMULATOR_CUH\n#include <MnBase/Concurrency/Concurrency.h>\n#include <MnBase/Meta/"
},
{
"path": "Projects/GMPM/grid_buffer.cuh",
"chars": 1870,
"preview": "#ifndef GRID_BUFFER_CUH\n#define GRID_BUFFER_CUH\n#include <MnSystem/Cuda/HostUtils.hpp>\n\n#include \"mgmpm_kernels.cuh\"\n#in"
},
{
"path": "Projects/GMPM/hash_table.cuh",
"chars": 5706,
"preview": "#ifndef HASH_TABLE_CUH\n#define HASH_TABLE_CUH\n#include <MnBase/Object/Structural.h>\n\n#include <MnSystem/Cuda/HostUtils.h"
},
{
"path": "Projects/GMPM/mgmpm_kernels.cuh",
"chars": 58374,
"preview": "#ifndef MULTI_GMPM_KERNELS_CUH\n#define MULTI_GMPM_KERNELS_CUH\n\n#include <MnBase/Math/Matrix/MatrixUtils.h>\n\n#include <Mn"
},
{
"path": "Projects/GMPM/particle_buffer.cuh",
"chars": 14279,
"preview": "#ifndef PARTICLE_BUFFER_CUH\n#define PARTICLE_BUFFER_CUH\n#include <MnBase/Meta/Polymorphism.h>\n\n#include <MnSystem/Cuda/H"
},
{
"path": "Projects/GMPM/partition_domain.h",
"chars": 1713,
"preview": "#ifndef __PARTITION_DOMAIN_H_\n#define __PARTITION_DOMAIN_H_\n#include <MnBase/Math/Vec.h>\n#include <MnBase/Meta/Polymorph"
},
{
"path": "Projects/GMPM/scenes/scene.json",
"chars": 1008,
"preview": "{\n\t\"simulation\": {\n\t\t\"gpuid\": 0,\n\t\t\"fps\": 1200,\n\t\t\"frames\": 120,\n\t\t\"default_dt\": 5e-6\n\t},\n\t\"models\": [\n\t\t{\n\t\t\t\"type\": \"p"
},
{
"path": "Projects/GMPM/settings.h",
"chars": 3503,
"preview": "#ifndef SETTINGS_H\n#define SETTINGS_H\n#include <MnBase/Math/Vec.h>\n#include <MnBase/Object/Structural.h>\n\n#include <arra"
},
{
"path": "Projects/GMPM/utility_funcs.hpp",
"chars": 1856,
"preview": "#ifndef UTILITY_FUNCS_HPP\n#define UTILITY_FUNCS_HPP\n#include \"settings.h\"\n\nnamespace mn {\n\n//TODO: Maybe create paramete"
},
{
"path": "Projects/MGSP/CMakeLists.txt",
"chars": 379,
"preview": "if (CUDA_FOUND)\n\tadd_cuda_executable(mgsp)\n\t\n\ttarget_sources(mgsp \n\t\tPRIVATE mgsp.cu\n\t)\n\t\n\ttarget_link_libraries(mgs"
},
{
"path": "Projects/MGSP/boundary_condition.cuh",
"chars": 12402,
"preview": "#ifndef BOUNDARY_CONDITION_CUH\n#define BOUNDARY_CONDITION_CUH\n#include <MnBase/Math/Matrix/MatrixUtils.h>\n#include <MnBa"
},
{
"path": "Projects/MGSP/constitutive_models.cuh",
"chars": 12265,
"preview": "#ifndef CONSTITUTIVE_MODELS_CUH\n#define CONSTITUTIVE_MODELS_CUH\n#include <MnBase/Math/Matrix/MatrixUtils.h>\n#include <Mn"
},
{
"path": "Projects/MGSP/grid_buffer.cuh",
"chars": 2154,
"preview": "#ifndef GRID_BUFFER_CUH\n#define GRID_BUFFER_CUH\n#include <MnSystem/Cuda/HostUtils.hpp>\n\n#include \"mgmpm_kernels.cuh\"\n#in"
},
{
"path": "Projects/MGSP/halo_buffer.cuh",
"chars": 2926,
"preview": "#ifndef HALO_BUFFER_CUH\n#define HALO_BUFFER_CUH\n#include <MnBase/Meta/Polymorphism.h>\n\n#include \"grid_buffer.cuh\"\n#inclu"
},
{
"path": "Projects/MGSP/halo_kernels.cuh",
"chars": 6278,
"preview": "#ifndef HALO_KERNELS_CUH\n#define HALO_KERNELS_CUH\n\n#include <MnBase/Math/Matrix/MatrixUtils.h>\n\n#include <MnBase/Algorit"
},
{
"path": "Projects/MGSP/hash_table.cuh",
"chars": 9461,
"preview": "#ifndef HASH_TABLE_CUH\n#define HASH_TABLE_CUH\n\n#include <MnSystem/Cuda/HostUtils.hpp>\n\n#include \"mgmpm_kernels.cuh\"\n#inc"
},
{
"path": "Projects/MGSP/mgmpm_kernels.cuh",
"chars": 83065,
"preview": "#ifndef MULTI_GMPM_KERNELS_CUH\n#define MULTI_GMPM_KERNELS_CUH\n\n#include <MnBase/Math/Matrix/MatrixUtils.h>\n\n#include <Mn"
},
{
"path": "Projects/MGSP/mgsp.cu",
"chars": 3731,
"preview": "#include <MnBase/Geometry/GeometrySampler.h>\n#include <MnBase/Math/Vec.h>\n#include <MnSystem/Cuda/Cuda.h>\n#include <MnSy"
},
{
"path": "Projects/MGSP/mgsp_benchmark.cuh",
"chars": 35752,
"preview": "#ifndef MGSP_BENCHMARK_CUH\n#define MGSP_BENCHMARK_CUH\n#include <MnBase/Concurrency/Concurrency.h>\n#include <MnBase/Meta/"
},
{
"path": "Projects/MGSP/particle_buffer.cuh",
"chars": 9808,
"preview": "#ifndef PARTICLE_BUFFER_CUH\n#define PARTICLE_BUFFER_CUH\n#include <MnBase/Meta/Polymorphism.h>\n\n#include \"settings.h\"\n\n//"
},
{
"path": "Projects/MGSP/partition_domain.h",
"chars": 1747,
"preview": "#ifndef PARTITION_DOMAIN_H\n#define PARTITION_DOMAIN_H\n#include <MnBase/Math/Vec.h>\n#include <MnBase/Meta/Polymorphism.h>"
},
{
"path": "Projects/MGSP/settings.h",
"chars": 3945,
"preview": "#ifndef SETTINGS_H\n#define SETTINGS_H\n#include <MnBase/Math/Vec.h>\n#include <MnBase/Object/Structural.h>\n\n#include <arra"
},
{
"path": "Projects/MGSP/utility_funcs.hpp",
"chars": 1457,
"preview": "#ifndef UTILITY_FUNCS_HPP\n#define UTILITY_FUNCS_HPP\n#include \"settings.h\"\n\nnamespace mn {\n\n//TODO: Maybe create paramete"
},
{
"path": "Projects/TaichiScripts/gmpm.py",
"chars": 2472,
"preview": "import taichi as ti\n\nti.init(arch=ti.cuda)\n# sim setup\ndt = 1e-4\ndim = 3\ndomain_size = 256\ndx, inv_dx = 1 / domain_size,"
},
{
"path": "README.md",
"chars": 6732,
"preview": "# A Massively Parallel and Scalable Multi-GPU Material Point Method\n\n<div align=\"left\">\n <a href=\"https://claymore.re"
},
{
"path": "docs/benchmark.rst",
"chars": 2479,
"preview": "Benchmark\n==================\n\nSettings\n--------\nBenchmark settings of each project are set within its directory (e.g. *P"
},
{
"path": "docs/compilation.rst",
"chars": 2098,
"preview": "Compilation\n=============\n\nThis is a cross-platform C++/CUDA cmake project. \nThe minimum version requirement of **CMake*"
},
{
"path": "docs/conf.py",
"chars": 5587,
"preview": "# -*- coding: utf-8 -*-\n#\n# Mn documentation build configuration file, created by\n# sphinx-quickstart on Wed May 27 06:1"
},
{
"path": "docs/credits.rst",
"chars": 249,
"preview": "Acknowledgement\n===============\n\nWe thank Yuanming Hu for useful discussions and proofreading, Feng Gao for his help on "
},
{
"path": "docs/datastructure.rst",
"chars": 3540,
"preview": "Data Structure\n==============\nData structures in a MPM simulation usually need to model the particles, the grids and the"
},
{
"path": "docs/index.rst",
"chars": 419,
"preview": "Claymore Documentation\n==============================\n\n.. toctree::\n :caption: Overview\n :maxdepth: 3\n\n overview\n "
},
{
"path": "docs/multigmpm.rst",
"chars": 1764,
"preview": "Multi-GPU Design\n================\n\nReduce Memory Overhead\n----------------------\nTo extend from using a single GPU to ru"
},
{
"path": "docs/overview.rst",
"chars": 3820,
"preview": "Overview\n=============\n\nThis is the opensource code **Claymore** for the SIGGRAPH 2020 paper:\n\n**A Massively Parallel an"
},
{
"path": "docs/philosophy.rst",
"chars": 2651,
"preview": "Design Philosophy\n=================\n\nData-Oriented Design\n--------------------\nDue to the increased overhead of memory o"
},
{
"path": "docs/pipeline.rst",
"chars": 1259,
"preview": "Simulator Pipeline\n==================\n\nOur MPM simulator adopts the explicit time-integration scheme. \n\nThe conventional"
},
{
"path": "docs/sparsity.rst",
"chars": 4475,
"preview": "Sparse Data Structures\n======================\n\nIn many graphics applications, e.g. ray tracing, collision detection, nei"
},
{
"path": "docs/structural.rst",
"chars": 14315,
"preview": "Hierarchy Composition\n=====================\n\nMotivation\n----------\nFollowing the principle **Data-Oriented Design**, `Yu"
},
{
"path": "docs/system.rst",
"chars": 904,
"preview": "System\n======\n\nTo conveniently reuse the code required for a specific type of tasks, we build a precompiled and customiz"
},
{
"path": "docs/usage.rst",
"chars": 271,
"preview": "Usage\n=====\n\n**Q**: Use the codebase in another cmake c++ project.\n\n**A**: Directly include the codebase as a submodule,"
},
{
"path": "project_info.in",
"chars": 78,
"preview": "set(project_version 0.0.0)\nset(project_description \"gpu-based mpm simulator\")\n"
}
]
About this extraction
This page contains the full source code of the penn-graphics-research/claymore GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 183 files (2.1 MB), approximately 571.2k tokens, and a symbol index with 1235 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.