Copy disabled (too large)
Download .txt
Showing preview only (108,488K chars total). Download the full file to get everything.
Repository: ajith-ab/react-native-receive-sharing-intent
Branch: master
Commit: b375726ee9e8
Files: 13329
Total size: 129.0 MB
Directory structure:
gitextract_f_9f_4qy/
├── .gitignore
├── .npmignore
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── android/
│ ├── build.gradle
│ ├── gradle.properties
│ └── src/
│ └── main/
│ ├── AndroidManifest.xml
│ └── java/
│ └── com/
│ └── reactnativereceivesharingintent/
│ ├── FileDirectory.kt
│ ├── ReceiveSharingIntentHelper.java
│ ├── ReceiveSharingIntentModule.java
│ └── ReceiveSharingIntentPackage.kt
├── babel.config.js
├── docs/
│ ├── .gitignore
│ ├── README.md
│ ├── babel.config.js
│ ├── docs/
│ │ ├── android.md
│ │ ├── author.md
│ │ ├── demo.md
│ │ ├── donate.md
│ │ ├── intro.md
│ │ └── ios.md
│ ├── docusaurus.config.js
│ ├── package.json
│ ├── sidebars.js
│ ├── src/
│ │ ├── components/
│ │ │ ├── HomepageFeatures.js
│ │ │ └── HomepageFeatures.module.css
│ │ ├── css/
│ │ │ └── custom.css
│ │ ├── pages/
│ │ │ ├── index.js
│ │ │ ├── index.module.css
│ │ │ └── markdown-page.md
│ │ └── theme/
│ │ └── Footer/
│ │ ├── index.tsx
│ │ └── styles.module.css
│ ├── static/
│ │ └── .nojekyll
│ └── tsconfig.json
├── example/
│ ├── android/
│ │ ├── app/
│ │ │ ├── build.gradle
│ │ │ ├── proguard-rules.pro
│ │ │ └── src/
│ │ │ ├── debug/
│ │ │ │ ├── AndroidManifest.xml
│ │ │ │ └── java/
│ │ │ │ └── com/
│ │ │ │ └── example/
│ │ │ │ └── reactnativereceivesharingintent/
│ │ │ │ └── ReactNativeFlipper.java
│ │ │ └── main/
│ │ │ ├── AndroidManifest.xml
│ │ │ ├── java/
│ │ │ │ └── com/
│ │ │ │ └── example/
│ │ │ │ └── reactnativereceivesharingintent/
│ │ │ │ ├── MainActivity.java
│ │ │ │ └── MainApplication.java
│ │ │ └── res/
│ │ │ └── values/
│ │ │ ├── strings.xml
│ │ │ └── styles.xml
│ │ ├── build.gradle
│ │ ├── gradle/
│ │ │ └── wrapper/
│ │ │ ├── gradle-wrapper.jar
│ │ │ └── gradle-wrapper.properties
│ │ ├── gradle.properties
│ │ ├── gradlew
│ │ ├── gradlew.bat
│ │ └── settings.gradle
│ ├── app.json
│ ├── babel.config.js
│ ├── index.tsx
│ ├── ios/
│ │ ├── File.swift
│ │ ├── Podfile
│ │ ├── Pods/
│ │ │ ├── DoubleConversion/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── README
│ │ │ │ └── double-conversion/
│ │ │ │ ├── bignum-dtoa.cc
│ │ │ │ ├── bignum-dtoa.h
│ │ │ │ ├── bignum.cc
│ │ │ │ ├── bignum.h
│ │ │ │ ├── cached-powers.cc
│ │ │ │ ├── cached-powers.h
│ │ │ │ ├── diy-fp.cc
│ │ │ │ ├── diy-fp.h
│ │ │ │ ├── double-conversion.cc
│ │ │ │ ├── double-conversion.h
│ │ │ │ ├── fast-dtoa.cc
│ │ │ │ ├── fast-dtoa.h
│ │ │ │ ├── fixed-dtoa.cc
│ │ │ │ ├── fixed-dtoa.h
│ │ │ │ ├── ieee.h
│ │ │ │ ├── strtod.cc
│ │ │ │ ├── strtod.h
│ │ │ │ └── utils.h
│ │ │ ├── Folly/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── README.md
│ │ │ │ └── folly/
│ │ │ │ ├── AtomicHashArray-inl.h
│ │ │ │ ├── AtomicHashArray.h
│ │ │ │ ├── AtomicHashMap-inl.h
│ │ │ │ ├── AtomicHashMap.h
│ │ │ │ ├── AtomicIntrusiveLinkedList.h
│ │ │ │ ├── AtomicLinkedList.h
│ │ │ │ ├── AtomicUnorderedMap.h
│ │ │ │ ├── Benchmark.h
│ │ │ │ ├── Bits.h
│ │ │ │ ├── CPortability.h
│ │ │ │ ├── CachelinePadded.h
│ │ │ │ ├── CancellationToken-inl.h
│ │ │ │ ├── CancellationToken.h
│ │ │ │ ├── Chrono.h
│ │ │ │ ├── ClockGettimeWrappers.h
│ │ │ │ ├── ConcurrentBitSet.h
│ │ │ │ ├── ConcurrentSkipList-inl.h
│ │ │ │ ├── ConcurrentSkipList.h
│ │ │ │ ├── ConstexprMath.h
│ │ │ │ ├── Conv.cpp
│ │ │ │ ├── Conv.h
│ │ │ │ ├── CppAttributes.h
│ │ │ │ ├── CpuId.h
│ │ │ │ ├── DefaultKeepAliveExecutor.h
│ │ │ │ ├── Demangle.cpp
│ │ │ │ ├── Demangle.h
│ │ │ │ ├── DiscriminatedPtr.h
│ │ │ │ ├── DynamicConverter.h
│ │ │ │ ├── Exception.h
│ │ │ │ ├── ExceptionString.h
│ │ │ │ ├── ExceptionWrapper-inl.h
│ │ │ │ ├── ExceptionWrapper.h
│ │ │ │ ├── Executor.h
│ │ │ │ ├── Expected.h
│ │ │ │ ├── FBString.h
│ │ │ │ ├── FBVector.h
│ │ │ │ ├── File.h
│ │ │ │ ├── FileUtil.cpp
│ │ │ │ ├── FileUtil.h
│ │ │ │ ├── Fingerprint.h
│ │ │ │ ├── FixedString.h
│ │ │ │ ├── Format-inl.h
│ │ │ │ ├── Format.cpp
│ │ │ │ ├── Format.h
│ │ │ │ ├── FormatArg.h
│ │ │ │ ├── FormatTraits.h
│ │ │ │ ├── Function.h
│ │ │ │ ├── GLog.h
│ │ │ │ ├── GroupVarint.h
│ │ │ │ ├── Hash.h
│ │ │ │ ├── IPAddress.h
│ │ │ │ ├── IPAddressException.h
│ │ │ │ ├── IPAddressV4.h
│ │ │ │ ├── IPAddressV6.h
│ │ │ │ ├── Indestructible.h
│ │ │ │ ├── IndexedMemPool.h
│ │ │ │ ├── IntrusiveList.h
│ │ │ │ ├── Lazy.h
│ │ │ │ ├── Likely.h
│ │ │ │ ├── LockTraits.h
│ │ │ │ ├── MPMCPipeline.h
│ │ │ │ ├── MPMCQueue.h
│ │ │ │ ├── MacAddress.h
│ │ │ │ ├── MapUtil.h
│ │ │ │ ├── Math.h
│ │ │ │ ├── Memory.h
│ │ │ │ ├── MicroLock.h
│ │ │ │ ├── MicroSpinLock.h
│ │ │ │ ├── MoveWrapper.h
│ │ │ │ ├── Optional.h
│ │ │ │ ├── Overload.h
│ │ │ │ ├── PackedSyncPtr.h
│ │ │ │ ├── Padded.h
│ │ │ │ ├── Poly-inl.h
│ │ │ │ ├── Poly.h
│ │ │ │ ├── PolyException.h
│ │ │ │ ├── Portability.h
│ │ │ │ ├── Preprocessor.h
│ │ │ │ ├── ProducerConsumerQueue.h
│ │ │ │ ├── RWSpinLock.h
│ │ │ │ ├── Random-inl.h
│ │ │ │ ├── Random.h
│ │ │ │ ├── Range.h
│ │ │ │ ├── Replaceable.h
│ │ │ │ ├── ScopeGuard.cpp
│ │ │ │ ├── ScopeGuard.h
│ │ │ │ ├── SharedMutex.h
│ │ │ │ ├── Singleton-inl.h
│ │ │ │ ├── Singleton.h
│ │ │ │ ├── SingletonThreadLocal.h
│ │ │ │ ├── SocketAddress.h
│ │ │ │ ├── SpinLock.h
│ │ │ │ ├── String-inl.h
│ │ │ │ ├── String.cpp
│ │ │ │ ├── String.h
│ │ │ │ ├── Subprocess.h
│ │ │ │ ├── Synchronized.h
│ │ │ │ ├── SynchronizedPtr.h
│ │ │ │ ├── ThreadCachedInt.h
│ │ │ │ ├── ThreadLocal.h
│ │ │ │ ├── TimeoutQueue.h
│ │ │ │ ├── TokenBucket.h
│ │ │ │ ├── Traits.h
│ │ │ │ ├── Try-inl.h
│ │ │ │ ├── Try.h
│ │ │ │ ├── UTF8String.h
│ │ │ │ ├── Unicode.cpp
│ │ │ │ ├── Unicode.h
│ │ │ │ ├── Unit.h
│ │ │ │ ├── Uri-inl.h
│ │ │ │ ├── Uri.h
│ │ │ │ ├── Utility.h
│ │ │ │ ├── Varint.h
│ │ │ │ ├── VirtualExecutor.h
│ │ │ │ ├── container/
│ │ │ │ │ ├── Access.h
│ │ │ │ │ ├── Array.h
│ │ │ │ │ ├── BitIterator.h
│ │ │ │ │ ├── Enumerate.h
│ │ │ │ │ ├── EvictingCacheMap.h
│ │ │ │ │ ├── F14Map-fwd.h
│ │ │ │ │ ├── F14Map.h
│ │ │ │ │ ├── F14Set-fwd.h
│ │ │ │ │ ├── F14Set.h
│ │ │ │ │ ├── Foreach-inl.h
│ │ │ │ │ ├── Foreach.h
│ │ │ │ │ ├── HeterogeneousAccess-fwd.h
│ │ │ │ │ ├── HeterogeneousAccess.h
│ │ │ │ │ ├── Iterator.h
│ │ │ │ │ ├── Merge.h
│ │ │ │ │ ├── SparseByteSet.h
│ │ │ │ │ └── detail/
│ │ │ │ │ ├── BitIteratorDetail.h
│ │ │ │ │ ├── F14Defaults.h
│ │ │ │ │ ├── F14IntrinsicsAvailability.h
│ │ │ │ │ ├── F14Mask.h
│ │ │ │ │ ├── F14Policy.h
│ │ │ │ │ ├── F14Table.cpp
│ │ │ │ │ ├── F14Table.h
│ │ │ │ │ └── Util.h
│ │ │ │ ├── detail/
│ │ │ │ │ ├── AsyncTrace.h
│ │ │ │ │ ├── AtFork.h
│ │ │ │ │ ├── AtomicHashUtils.h
│ │ │ │ │ ├── AtomicUnorderedMapUtils.h
│ │ │ │ │ ├── Demangle.cpp
│ │ │ │ │ ├── Demangle.h
│ │ │ │ │ ├── DiscriminatedPtrDetail.h
│ │ │ │ │ ├── FileUtilDetail.h
│ │ │ │ │ ├── FingerprintPolynomial.h
│ │ │ │ │ ├── Futex-inl.h
│ │ │ │ │ ├── Futex.h
│ │ │ │ │ ├── GroupVarintDetail.h
│ │ │ │ │ ├── IPAddress.h
│ │ │ │ │ ├── IPAddressSource.h
│ │ │ │ │ ├── Iterators.h
│ │ │ │ │ ├── MPMCPipelineDetail.h
│ │ │ │ │ ├── MemoryIdler.h
│ │ │ │ │ ├── PolyDetail.h
│ │ │ │ │ ├── RangeCommon.h
│ │ │ │ │ ├── RangeSse42.h
│ │ │ │ │ ├── Singleton.h
│ │ │ │ │ ├── SingletonStackTrace.h
│ │ │ │ │ ├── SlowFingerprint.h
│ │ │ │ │ ├── SocketFastOpen.h
│ │ │ │ │ ├── Sse.h
│ │ │ │ │ ├── StaticSingletonManager.h
│ │ │ │ │ ├── ThreadLocalDetail.h
│ │ │ │ │ ├── TurnSequencer.h
│ │ │ │ │ ├── TypeList.h
│ │ │ │ │ ├── UniqueInstance.cpp
│ │ │ │ │ └── UniqueInstance.h
│ │ │ │ ├── dynamic-inl.h
│ │ │ │ ├── dynamic.cpp
│ │ │ │ ├── dynamic.h
│ │ │ │ ├── functional/
│ │ │ │ │ ├── ApplyTuple.h
│ │ │ │ │ ├── Invoke.h
│ │ │ │ │ └── Partial.h
│ │ │ │ ├── hash/
│ │ │ │ │ ├── Checksum.h
│ │ │ │ │ ├── FarmHash.h
│ │ │ │ │ ├── Hash.h
│ │ │ │ │ ├── SpookyHashV1.h
│ │ │ │ │ ├── SpookyHashV2.cpp
│ │ │ │ │ └── SpookyHashV2.h
│ │ │ │ ├── json.cpp
│ │ │ │ ├── json.h
│ │ │ │ ├── json_patch.h
│ │ │ │ ├── json_pointer.cpp
│ │ │ │ ├── json_pointer.h
│ │ │ │ ├── lang/
│ │ │ │ │ ├── Align.h
│ │ │ │ │ ├── Aligned.h
│ │ │ │ │ ├── Assume.cpp
│ │ │ │ │ ├── Assume.h
│ │ │ │ │ ├── Bits.h
│ │ │ │ │ ├── CString.cpp
│ │ │ │ │ ├── CString.h
│ │ │ │ │ ├── Cast.h
│ │ │ │ │ ├── CheckedMath.h
│ │ │ │ │ ├── CustomizationPoint.h
│ │ │ │ │ ├── Exception.h
│ │ │ │ │ ├── Launder.h
│ │ │ │ │ ├── Ordering.h
│ │ │ │ │ ├── Pretty.h
│ │ │ │ │ ├── PropagateConst.h
│ │ │ │ │ ├── RValueReferenceWrapper.h
│ │ │ │ │ ├── SafeAssert.cpp
│ │ │ │ │ ├── SafeAssert.h
│ │ │ │ │ ├── StaticConst.h
│ │ │ │ │ ├── TypeInfo.h
│ │ │ │ │ └── UncaughtExceptions.h
│ │ │ │ ├── memory/
│ │ │ │ │ ├── Arena-inl.h
│ │ │ │ │ ├── Arena.h
│ │ │ │ │ ├── EnableSharedFromThis.h
│ │ │ │ │ ├── MallctlHelper.h
│ │ │ │ │ ├── Malloc.h
│ │ │ │ │ ├── MemoryResource.h
│ │ │ │ │ ├── SanitizeLeak.h
│ │ │ │ │ ├── ThreadCachedArena.h
│ │ │ │ │ ├── UninitializedMemoryHacks.h
│ │ │ │ │ └── detail/
│ │ │ │ │ ├── MallocImpl.cpp
│ │ │ │ │ └── MallocImpl.h
│ │ │ │ ├── net/
│ │ │ │ │ ├── NetOps.cpp
│ │ │ │ │ ├── NetOps.h
│ │ │ │ │ ├── NetworkSocket.h
│ │ │ │ │ └── detail/
│ │ │ │ │ └── SocketFileDescriptorMap.h
│ │ │ │ ├── portability/
│ │ │ │ │ ├── Asm.h
│ │ │ │ │ ├── Atomic.h
│ │ │ │ │ ├── Builtins.h
│ │ │ │ │ ├── Config.h
│ │ │ │ │ ├── Constexpr.h
│ │ │ │ │ ├── Dirent.h
│ │ │ │ │ ├── Event.h
│ │ │ │ │ ├── Fcntl.h
│ │ │ │ │ ├── GFlags.h
│ │ │ │ │ ├── GMock.h
│ │ │ │ │ ├── GTest.h
│ │ │ │ │ ├── IOVec.h
│ │ │ │ │ ├── Libgen.h
│ │ │ │ │ ├── Malloc.h
│ │ │ │ │ ├── Math.h
│ │ │ │ │ ├── Memory.h
│ │ │ │ │ ├── OpenSSL.h
│ │ │ │ │ ├── PThread.h
│ │ │ │ │ ├── Sched.h
│ │ │ │ │ ├── Semaphore.h
│ │ │ │ │ ├── Sockets.h
│ │ │ │ │ ├── Stdio.h
│ │ │ │ │ ├── Stdlib.h
│ │ │ │ │ ├── String.h
│ │ │ │ │ ├── SysFile.h
│ │ │ │ │ ├── SysMembarrier.h
│ │ │ │ │ ├── SysMman.h
│ │ │ │ │ ├── SysResource.h
│ │ │ │ │ ├── SysStat.h
│ │ │ │ │ ├── SysSyscall.h
│ │ │ │ │ ├── SysTime.h
│ │ │ │ │ ├── SysTypes.h
│ │ │ │ │ ├── SysUio.cpp
│ │ │ │ │ ├── SysUio.h
│ │ │ │ │ ├── Syslog.h
│ │ │ │ │ ├── Time.h
│ │ │ │ │ ├── Unistd.h
│ │ │ │ │ └── Windows.h
│ │ │ │ ├── small_vector.h
│ │ │ │ ├── sorted_vector_types.h
│ │ │ │ └── stop_watch.h
│ │ │ ├── Local Podspecs/
│ │ │ │ ├── DoubleConversion.podspec.json
│ │ │ │ ├── FBLazyVector.podspec.json
│ │ │ │ ├── FBReactNativeSpec.podspec.json
│ │ │ │ ├── Folly.podspec.json
│ │ │ │ ├── RCTRequired.podspec.json
│ │ │ │ ├── RCTTypeSafety.podspec.json
│ │ │ │ ├── React-Core.podspec.json
│ │ │ │ ├── React-CoreModules.podspec.json
│ │ │ │ ├── React-RCTActionSheet.podspec.json
│ │ │ │ ├── React-RCTAnimation.podspec.json
│ │ │ │ ├── React-RCTBlob.podspec.json
│ │ │ │ ├── React-RCTImage.podspec.json
│ │ │ │ ├── React-RCTLinking.podspec.json
│ │ │ │ ├── React-RCTNetwork.podspec.json
│ │ │ │ ├── React-RCTSettings.podspec.json
│ │ │ │ ├── React-RCTText.podspec.json
│ │ │ │ ├── React-RCTVibration.podspec.json
│ │ │ │ ├── React-callinvoker.podspec.json
│ │ │ │ ├── React-cxxreact.podspec.json
│ │ │ │ ├── React-jsi.podspec.json
│ │ │ │ ├── React-jsiexecutor.podspec.json
│ │ │ │ ├── React-jsinspector.podspec.json
│ │ │ │ ├── React.podspec.json
│ │ │ │ ├── ReactCommon.podspec.json
│ │ │ │ ├── Yoga.podspec.json
│ │ │ │ ├── glog.podspec.json
│ │ │ │ └── react-native-receive-sharing-intent.podspec.json
│ │ │ ├── Pods.xcodeproj/
│ │ │ │ └── project.pbxproj
│ │ │ ├── Target Support Files/
│ │ │ │ ├── DoubleConversion/
│ │ │ │ │ ├── DoubleConversion-dummy.m
│ │ │ │ │ ├── DoubleConversion-prefix.pch
│ │ │ │ │ ├── DoubleConversion.debug.xcconfig
│ │ │ │ │ └── DoubleConversion.release.xcconfig
│ │ │ │ ├── FBLazyVector/
│ │ │ │ │ ├── FBLazyVector.debug.xcconfig
│ │ │ │ │ └── FBLazyVector.release.xcconfig
│ │ │ │ ├── FBReactNativeSpec/
│ │ │ │ │ ├── FBReactNativeSpec-dummy.m
│ │ │ │ │ ├── FBReactNativeSpec-prefix.pch
│ │ │ │ │ ├── FBReactNativeSpec.debug.xcconfig
│ │ │ │ │ └── FBReactNativeSpec.release.xcconfig
│ │ │ │ ├── Folly/
│ │ │ │ │ ├── Folly-dummy.m
│ │ │ │ │ ├── Folly-prefix.pch
│ │ │ │ │ ├── Folly.debug.xcconfig
│ │ │ │ │ └── Folly.release.xcconfig
│ │ │ │ ├── Pods-ReceiveSharingIntentExample/
│ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-acknowledgements.markdown
│ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-acknowledgements.plist
│ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-dummy.m
│ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-resources.sh
│ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-umbrella.h
│ │ │ │ │ ├── Pods-ReceiveSharingIntentExample.debug.xcconfig
│ │ │ │ │ ├── Pods-ReceiveSharingIntentExample.modulemap
│ │ │ │ │ └── Pods-ReceiveSharingIntentExample.release.xcconfig
│ │ │ │ ├── RCTRequired/
│ │ │ │ │ ├── RCTRequired.debug.xcconfig
│ │ │ │ │ └── RCTRequired.release.xcconfig
│ │ │ │ ├── RCTTypeSafety/
│ │ │ │ │ ├── RCTTypeSafety-dummy.m
│ │ │ │ │ ├── RCTTypeSafety-prefix.pch
│ │ │ │ │ ├── RCTTypeSafety.debug.xcconfig
│ │ │ │ │ └── RCTTypeSafety.release.xcconfig
│ │ │ │ ├── React/
│ │ │ │ │ ├── React.debug.xcconfig
│ │ │ │ │ └── React.release.xcconfig
│ │ │ │ ├── React-Core/
│ │ │ │ │ ├── React-Core-dummy.m
│ │ │ │ │ ├── React-Core-prefix.pch
│ │ │ │ │ ├── React-Core-umbrella.h
│ │ │ │ │ ├── React-Core.debug.xcconfig
│ │ │ │ │ ├── React-Core.modulemap
│ │ │ │ │ ├── React-Core.release.xcconfig
│ │ │ │ │ └── ResourceBundle-AccessibilityResources-React-Core-Info.plist
│ │ │ │ ├── React-CoreModules/
│ │ │ │ │ ├── React-CoreModules-dummy.m
│ │ │ │ │ ├── React-CoreModules-prefix.pch
│ │ │ │ │ ├── React-CoreModules.debug.xcconfig
│ │ │ │ │ └── React-CoreModules.release.xcconfig
│ │ │ │ ├── React-RCTActionSheet/
│ │ │ │ │ ├── React-RCTActionSheet.debug.xcconfig
│ │ │ │ │ └── React-RCTActionSheet.release.xcconfig
│ │ │ │ ├── React-RCTAnimation/
│ │ │ │ │ ├── React-RCTAnimation-dummy.m
│ │ │ │ │ ├── React-RCTAnimation-prefix.pch
│ │ │ │ │ ├── React-RCTAnimation.debug.xcconfig
│ │ │ │ │ └── React-RCTAnimation.release.xcconfig
│ │ │ │ ├── React-RCTBlob/
│ │ │ │ │ ├── React-RCTBlob-dummy.m
│ │ │ │ │ ├── React-RCTBlob-prefix.pch
│ │ │ │ │ ├── React-RCTBlob.debug.xcconfig
│ │ │ │ │ └── React-RCTBlob.release.xcconfig
│ │ │ │ ├── React-RCTImage/
│ │ │ │ │ ├── React-RCTImage-dummy.m
│ │ │ │ │ ├── React-RCTImage-prefix.pch
│ │ │ │ │ ├── React-RCTImage.debug.xcconfig
│ │ │ │ │ └── React-RCTImage.release.xcconfig
│ │ │ │ ├── React-RCTLinking/
│ │ │ │ │ ├── React-RCTLinking-dummy.m
│ │ │ │ │ ├── React-RCTLinking-prefix.pch
│ │ │ │ │ ├── React-RCTLinking.debug.xcconfig
│ │ │ │ │ └── React-RCTLinking.release.xcconfig
│ │ │ │ ├── React-RCTNetwork/
│ │ │ │ │ ├── React-RCTNetwork-dummy.m
│ │ │ │ │ ├── React-RCTNetwork-prefix.pch
│ │ │ │ │ ├── React-RCTNetwork.debug.xcconfig
│ │ │ │ │ └── React-RCTNetwork.release.xcconfig
│ │ │ │ ├── React-RCTSettings/
│ │ │ │ │ ├── React-RCTSettings-dummy.m
│ │ │ │ │ ├── React-RCTSettings-prefix.pch
│ │ │ │ │ ├── React-RCTSettings.debug.xcconfig
│ │ │ │ │ └── React-RCTSettings.release.xcconfig
│ │ │ │ ├── React-RCTText/
│ │ │ │ │ ├── React-RCTText-dummy.m
│ │ │ │ │ ├── React-RCTText-prefix.pch
│ │ │ │ │ ├── React-RCTText.debug.xcconfig
│ │ │ │ │ └── React-RCTText.release.xcconfig
│ │ │ │ ├── React-RCTVibration/
│ │ │ │ │ ├── React-RCTVibration-dummy.m
│ │ │ │ │ ├── React-RCTVibration-prefix.pch
│ │ │ │ │ ├── React-RCTVibration.debug.xcconfig
│ │ │ │ │ └── React-RCTVibration.release.xcconfig
│ │ │ │ ├── React-callinvoker/
│ │ │ │ │ ├── React-callinvoker.debug.xcconfig
│ │ │ │ │ └── React-callinvoker.release.xcconfig
│ │ │ │ ├── React-cxxreact/
│ │ │ │ │ ├── React-cxxreact-dummy.m
│ │ │ │ │ ├── React-cxxreact-prefix.pch
│ │ │ │ │ ├── React-cxxreact.debug.xcconfig
│ │ │ │ │ └── React-cxxreact.release.xcconfig
│ │ │ │ ├── React-jsi/
│ │ │ │ │ ├── React-jsi-dummy.m
│ │ │ │ │ ├── React-jsi-prefix.pch
│ │ │ │ │ ├── React-jsi.debug.xcconfig
│ │ │ │ │ └── React-jsi.release.xcconfig
│ │ │ │ ├── React-jsiexecutor/
│ │ │ │ │ ├── React-jsiexecutor-dummy.m
│ │ │ │ │ ├── React-jsiexecutor-prefix.pch
│ │ │ │ │ ├── React-jsiexecutor.debug.xcconfig
│ │ │ │ │ └── React-jsiexecutor.release.xcconfig
│ │ │ │ ├── React-jsinspector/
│ │ │ │ │ ├── React-jsinspector-dummy.m
│ │ │ │ │ ├── React-jsinspector-prefix.pch
│ │ │ │ │ ├── React-jsinspector.debug.xcconfig
│ │ │ │ │ └── React-jsinspector.release.xcconfig
│ │ │ │ ├── ReactCommon/
│ │ │ │ │ ├── ReactCommon-dummy.m
│ │ │ │ │ ├── ReactCommon-prefix.pch
│ │ │ │ │ ├── ReactCommon.debug.xcconfig
│ │ │ │ │ └── ReactCommon.release.xcconfig
│ │ │ │ ├── Yoga/
│ │ │ │ │ ├── Yoga-dummy.m
│ │ │ │ │ ├── Yoga-prefix.pch
│ │ │ │ │ ├── Yoga-umbrella.h
│ │ │ │ │ ├── Yoga.debug.xcconfig
│ │ │ │ │ ├── Yoga.modulemap
│ │ │ │ │ └── Yoga.release.xcconfig
│ │ │ │ ├── boost-for-react-native/
│ │ │ │ │ ├── boost-for-react-native.debug.xcconfig
│ │ │ │ │ └── boost-for-react-native.release.xcconfig
│ │ │ │ ├── glog/
│ │ │ │ │ ├── glog-dummy.m
│ │ │ │ │ ├── glog-prefix.pch
│ │ │ │ │ ├── glog.debug.xcconfig
│ │ │ │ │ └── glog.release.xcconfig
│ │ │ │ └── react-native-receive-sharing-intent/
│ │ │ │ ├── react-native-receive-sharing-intent-dummy.m
│ │ │ │ ├── react-native-receive-sharing-intent-prefix.pch
│ │ │ │ ├── react-native-receive-sharing-intent-umbrella.h
│ │ │ │ ├── react-native-receive-sharing-intent.debug.xcconfig
│ │ │ │ ├── react-native-receive-sharing-intent.modulemap
│ │ │ │ └── react-native-receive-sharing-intent.release.xcconfig
│ │ │ ├── boost-for-react-native/
│ │ │ │ ├── LICENSE_1_0.txt
│ │ │ │ ├── README.md
│ │ │ │ └── boost/
│ │ │ │ ├── accumulators/
│ │ │ │ │ ├── accumulators.hpp
│ │ │ │ │ ├── accumulators_fwd.hpp
│ │ │ │ │ ├── framework/
│ │ │ │ │ │ ├── accumulator_base.hpp
│ │ │ │ │ │ ├── accumulator_concept.hpp
│ │ │ │ │ │ ├── accumulator_set.hpp
│ │ │ │ │ │ ├── accumulators/
│ │ │ │ │ │ │ ├── droppable_accumulator.hpp
│ │ │ │ │ │ │ ├── external_accumulator.hpp
│ │ │ │ │ │ │ ├── reference_accumulator.hpp
│ │ │ │ │ │ │ └── value_accumulator.hpp
│ │ │ │ │ │ ├── depends_on.hpp
│ │ │ │ │ │ ├── external.hpp
│ │ │ │ │ │ ├── extractor.hpp
│ │ │ │ │ │ ├── features.hpp
│ │ │ │ │ │ └── parameters/
│ │ │ │ │ │ ├── accumulator.hpp
│ │ │ │ │ │ ├── sample.hpp
│ │ │ │ │ │ ├── weight.hpp
│ │ │ │ │ │ └── weights.hpp
│ │ │ │ │ ├── numeric/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── function1.hpp
│ │ │ │ │ │ │ ├── function2.hpp
│ │ │ │ │ │ │ ├── function3.hpp
│ │ │ │ │ │ │ ├── function4.hpp
│ │ │ │ │ │ │ ├── function_n.hpp
│ │ │ │ │ │ │ └── pod_singleton.hpp
│ │ │ │ │ │ ├── functional/
│ │ │ │ │ │ │ ├── complex.hpp
│ │ │ │ │ │ │ ├── valarray.hpp
│ │ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ └── functional_fwd.hpp
│ │ │ │ │ ├── statistics/
│ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ ├── covariance.hpp
│ │ │ │ │ │ ├── density.hpp
│ │ │ │ │ │ ├── error_of.hpp
│ │ │ │ │ │ ├── error_of_mean.hpp
│ │ │ │ │ │ ├── extended_p_square.hpp
│ │ │ │ │ │ ├── extended_p_square_quantile.hpp
│ │ │ │ │ │ ├── kurtosis.hpp
│ │ │ │ │ │ ├── max.hpp
│ │ │ │ │ │ ├── mean.hpp
│ │ │ │ │ │ ├── median.hpp
│ │ │ │ │ │ ├── min.hpp
│ │ │ │ │ │ ├── moment.hpp
│ │ │ │ │ │ ├── p_square_cumul_dist.hpp
│ │ │ │ │ │ ├── p_square_cumulative_distribution.hpp
│ │ │ │ │ │ ├── p_square_quantile.hpp
│ │ │ │ │ │ ├── parameters/
│ │ │ │ │ │ │ └── quantile_probability.hpp
│ │ │ │ │ │ ├── peaks_over_threshold.hpp
│ │ │ │ │ │ ├── pot_quantile.hpp
│ │ │ │ │ │ ├── pot_tail_mean.hpp
│ │ │ │ │ │ ├── rolling_count.hpp
│ │ │ │ │ │ ├── rolling_mean.hpp
│ │ │ │ │ │ ├── rolling_moment.hpp
│ │ │ │ │ │ ├── rolling_sum.hpp
│ │ │ │ │ │ ├── rolling_variance.hpp
│ │ │ │ │ │ ├── rolling_window.hpp
│ │ │ │ │ │ ├── skewness.hpp
│ │ │ │ │ │ ├── stats.hpp
│ │ │ │ │ │ ├── sum.hpp
│ │ │ │ │ │ ├── sum_kahan.hpp
│ │ │ │ │ │ ├── tail.hpp
│ │ │ │ │ │ ├── tail_mean.hpp
│ │ │ │ │ │ ├── tail_quantile.hpp
│ │ │ │ │ │ ├── tail_variate.hpp
│ │ │ │ │ │ ├── tail_variate_means.hpp
│ │ │ │ │ │ ├── times2_iterator.hpp
│ │ │ │ │ │ ├── variance.hpp
│ │ │ │ │ │ ├── variates/
│ │ │ │ │ │ │ └── covariate.hpp
│ │ │ │ │ │ ├── weighted_covariance.hpp
│ │ │ │ │ │ ├── weighted_density.hpp
│ │ │ │ │ │ ├── weighted_extended_p_square.hpp
│ │ │ │ │ │ ├── weighted_kurtosis.hpp
│ │ │ │ │ │ ├── weighted_mean.hpp
│ │ │ │ │ │ ├── weighted_median.hpp
│ │ │ │ │ │ ├── weighted_moment.hpp
│ │ │ │ │ │ ├── weighted_p_square_cumul_dist.hpp
│ │ │ │ │ │ ├── weighted_p_square_cumulative_distribution.hpp
│ │ │ │ │ │ ├── weighted_p_square_quantile.hpp
│ │ │ │ │ │ ├── weighted_peaks_over_threshold.hpp
│ │ │ │ │ │ ├── weighted_skewness.hpp
│ │ │ │ │ │ ├── weighted_sum.hpp
│ │ │ │ │ │ ├── weighted_sum_kahan.hpp
│ │ │ │ │ │ ├── weighted_tail_mean.hpp
│ │ │ │ │ │ ├── weighted_tail_quantile.hpp
│ │ │ │ │ │ ├── weighted_tail_variate_means.hpp
│ │ │ │ │ │ ├── weighted_variance.hpp
│ │ │ │ │ │ └── with_error.hpp
│ │ │ │ │ ├── statistics.hpp
│ │ │ │ │ └── statistics_fwd.hpp
│ │ │ │ ├── algorithm/
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── clamp.hpp
│ │ │ │ │ ├── cxx11/
│ │ │ │ │ │ ├── all_of.hpp
│ │ │ │ │ │ ├── any_of.hpp
│ │ │ │ │ │ ├── copy_if.hpp
│ │ │ │ │ │ ├── copy_n.hpp
│ │ │ │ │ │ ├── find_if_not.hpp
│ │ │ │ │ │ ├── iota.hpp
│ │ │ │ │ │ ├── is_partitioned.hpp
│ │ │ │ │ │ ├── is_permutation.hpp
│ │ │ │ │ │ ├── is_sorted.hpp
│ │ │ │ │ │ ├── none_of.hpp
│ │ │ │ │ │ ├── one_of.hpp
│ │ │ │ │ │ ├── partition_copy.hpp
│ │ │ │ │ │ └── partition_point.hpp
│ │ │ │ │ ├── cxx14/
│ │ │ │ │ │ ├── equal.hpp
│ │ │ │ │ │ ├── is_permutation.hpp
│ │ │ │ │ │ └── mismatch.hpp
│ │ │ │ │ ├── gather.hpp
│ │ │ │ │ ├── hex.hpp
│ │ │ │ │ ├── is_palindrome.hpp
│ │ │ │ │ ├── minmax.hpp
│ │ │ │ │ ├── minmax_element.hpp
│ │ │ │ │ ├── searching/
│ │ │ │ │ │ ├── boyer_moore.hpp
│ │ │ │ │ │ ├── boyer_moore_horspool.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── bm_traits.hpp
│ │ │ │ │ │ │ └── debugging.hpp
│ │ │ │ │ │ └── knuth_morris_pratt.hpp
│ │ │ │ │ ├── sort_subrange.hpp
│ │ │ │ │ ├── string/
│ │ │ │ │ │ ├── case_conv.hpp
│ │ │ │ │ │ ├── classification.hpp
│ │ │ │ │ │ ├── compare.hpp
│ │ │ │ │ │ ├── concept.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── constants.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── case_conv.hpp
│ │ │ │ │ │ │ ├── classification.hpp
│ │ │ │ │ │ │ ├── find_format.hpp
│ │ │ │ │ │ │ ├── find_format_all.hpp
│ │ │ │ │ │ │ ├── find_format_store.hpp
│ │ │ │ │ │ │ ├── find_iterator.hpp
│ │ │ │ │ │ │ ├── finder.hpp
│ │ │ │ │ │ │ ├── finder_regex.hpp
│ │ │ │ │ │ │ ├── formatter.hpp
│ │ │ │ │ │ │ ├── formatter_regex.hpp
│ │ │ │ │ │ │ ├── predicate.hpp
│ │ │ │ │ │ │ ├── replace_storage.hpp
│ │ │ │ │ │ │ ├── sequence.hpp
│ │ │ │ │ │ │ ├── trim.hpp
│ │ │ │ │ │ │ └── util.hpp
│ │ │ │ │ │ ├── erase.hpp
│ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ ├── find_format.hpp
│ │ │ │ │ │ ├── find_iterator.hpp
│ │ │ │ │ │ ├── finder.hpp
│ │ │ │ │ │ ├── formatter.hpp
│ │ │ │ │ │ ├── iter_find.hpp
│ │ │ │ │ │ ├── join.hpp
│ │ │ │ │ │ ├── predicate.hpp
│ │ │ │ │ │ ├── predicate_facade.hpp
│ │ │ │ │ │ ├── regex.hpp
│ │ │ │ │ │ ├── regex_find_format.hpp
│ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ ├── sequence_traits.hpp
│ │ │ │ │ │ ├── split.hpp
│ │ │ │ │ │ ├── std/
│ │ │ │ │ │ │ ├── list_traits.hpp
│ │ │ │ │ │ │ ├── rope_traits.hpp
│ │ │ │ │ │ │ ├── slist_traits.hpp
│ │ │ │ │ │ │ └── string_traits.hpp
│ │ │ │ │ │ ├── std_containers_traits.hpp
│ │ │ │ │ │ ├── trim.hpp
│ │ │ │ │ │ ├── trim_all.hpp
│ │ │ │ │ │ └── yes_no_type.hpp
│ │ │ │ │ ├── string.hpp
│ │ │ │ │ └── string_regex.hpp
│ │ │ │ ├── align/
│ │ │ │ │ ├── align.hpp
│ │ │ │ │ ├── align_down.hpp
│ │ │ │ │ ├── align_down_forward.hpp
│ │ │ │ │ ├── align_up.hpp
│ │ │ │ │ ├── align_up_forward.hpp
│ │ │ │ │ ├── aligned_alloc.hpp
│ │ │ │ │ ├── aligned_allocator.hpp
│ │ │ │ │ ├── aligned_allocator_adaptor.hpp
│ │ │ │ │ ├── aligned_allocator_adaptor_forward.hpp
│ │ │ │ │ ├── aligned_allocator_forward.hpp
│ │ │ │ │ ├── aligned_delete.hpp
│ │ │ │ │ ├── aligned_delete_forward.hpp
│ │ │ │ │ ├── alignment_of.hpp
│ │ │ │ │ ├── alignment_of_forward.hpp
│ │ │ │ │ ├── assume_aligned.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── address.hpp
│ │ │ │ │ │ ├── addressof.hpp
│ │ │ │ │ │ ├── align.hpp
│ │ │ │ │ │ ├── align_cxx11.hpp
│ │ │ │ │ │ ├── align_down.hpp
│ │ │ │ │ │ ├── align_up.hpp
│ │ │ │ │ │ ├── aligned_alloc.hpp
│ │ │ │ │ │ ├── aligned_alloc_android.hpp
│ │ │ │ │ │ ├── aligned_alloc_macos.hpp
│ │ │ │ │ │ ├── aligned_alloc_msvc.hpp
│ │ │ │ │ │ ├── aligned_alloc_posix.hpp
│ │ │ │ │ │ ├── aligned_alloc_sunos.hpp
│ │ │ │ │ │ ├── alignment_of.hpp
│ │ │ │ │ │ ├── alignment_of_clang.hpp
│ │ │ │ │ │ ├── alignment_of_codegear.hpp
│ │ │ │ │ │ ├── alignment_of_cxx11.hpp
│ │ │ │ │ │ ├── alignment_of_gcc.hpp
│ │ │ │ │ │ ├── alignment_of_msvc.hpp
│ │ │ │ │ │ ├── assume_aligned.hpp
│ │ │ │ │ │ ├── assume_aligned_clang.hpp
│ │ │ │ │ │ ├── assume_aligned_gcc.hpp
│ │ │ │ │ │ ├── assume_aligned_intel.hpp
│ │ │ │ │ │ ├── assume_aligned_msvc.hpp
│ │ │ │ │ │ ├── element_type.hpp
│ │ │ │ │ │ ├── integral_constant.hpp
│ │ │ │ │ │ ├── is_aligned.hpp
│ │ │ │ │ │ ├── is_alignment.hpp
│ │ │ │ │ │ ├── is_alignment_constant.hpp
│ │ │ │ │ │ ├── max_align.hpp
│ │ │ │ │ │ ├── max_count_of.hpp
│ │ │ │ │ │ ├── max_objects.hpp
│ │ │ │ │ │ ├── max_size.hpp
│ │ │ │ │ │ ├── min_size.hpp
│ │ │ │ │ │ ├── offset_object.hpp
│ │ │ │ │ │ └── remove_traits.hpp
│ │ │ │ │ ├── is_aligned.hpp
│ │ │ │ │ └── is_aligned_forward.hpp
│ │ │ │ ├── align.hpp
│ │ │ │ ├── aligned_storage.hpp
│ │ │ │ ├── any.hpp
│ │ │ │ ├── archive/
│ │ │ │ │ ├── add_facet.hpp
│ │ │ │ │ ├── archive_exception.hpp
│ │ │ │ │ ├── basic_archive.hpp
│ │ │ │ │ ├── basic_binary_iarchive.hpp
│ │ │ │ │ ├── basic_binary_iprimitive.hpp
│ │ │ │ │ ├── basic_binary_oarchive.hpp
│ │ │ │ │ ├── basic_binary_oprimitive.hpp
│ │ │ │ │ ├── basic_streambuf_locale_saver.hpp
│ │ │ │ │ ├── basic_text_iarchive.hpp
│ │ │ │ │ ├── basic_text_iprimitive.hpp
│ │ │ │ │ ├── basic_text_oarchive.hpp
│ │ │ │ │ ├── basic_text_oprimitive.hpp
│ │ │ │ │ ├── basic_xml_archive.hpp
│ │ │ │ │ ├── basic_xml_iarchive.hpp
│ │ │ │ │ ├── basic_xml_oarchive.hpp
│ │ │ │ │ ├── binary_iarchive.hpp
│ │ │ │ │ ├── binary_iarchive_impl.hpp
│ │ │ │ │ ├── binary_oarchive.hpp
│ │ │ │ │ ├── binary_oarchive_impl.hpp
│ │ │ │ │ ├── binary_wiarchive.hpp
│ │ │ │ │ ├── binary_woarchive.hpp
│ │ │ │ │ ├── codecvt_null.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── abi_prefix.hpp
│ │ │ │ │ │ ├── abi_suffix.hpp
│ │ │ │ │ │ ├── archive_serializer_map.hpp
│ │ │ │ │ │ ├── auto_link_archive.hpp
│ │ │ │ │ │ ├── auto_link_warchive.hpp
│ │ │ │ │ │ ├── basic_archive_impl.hpp
│ │ │ │ │ │ ├── basic_config.hpp
│ │ │ │ │ │ ├── basic_iarchive.hpp
│ │ │ │ │ │ ├── basic_iserializer.hpp
│ │ │ │ │ │ ├── basic_oarchive.hpp
│ │ │ │ │ │ ├── basic_oserializer.hpp
│ │ │ │ │ │ ├── basic_pointer_iserializer.hpp
│ │ │ │ │ │ ├── basic_pointer_oserializer.hpp
│ │ │ │ │ │ ├── basic_serializer.hpp
│ │ │ │ │ │ ├── basic_serializer_map.hpp
│ │ │ │ │ │ ├── check.hpp
│ │ │ │ │ │ ├── common_iarchive.hpp
│ │ │ │ │ │ ├── common_oarchive.hpp
│ │ │ │ │ │ ├── decl.hpp
│ │ │ │ │ │ ├── helper_collection.hpp
│ │ │ │ │ │ ├── interface_iarchive.hpp
│ │ │ │ │ │ ├── interface_oarchive.hpp
│ │ │ │ │ │ ├── iserializer.hpp
│ │ │ │ │ │ ├── oserializer.hpp
│ │ │ │ │ │ ├── polymorphic_iarchive_route.hpp
│ │ │ │ │ │ ├── polymorphic_oarchive_route.hpp
│ │ │ │ │ │ ├── register_archive.hpp
│ │ │ │ │ │ └── utf8_codecvt_facet.hpp
│ │ │ │ │ ├── dinkumware.hpp
│ │ │ │ │ ├── impl/
│ │ │ │ │ │ ├── archive_serializer_map.ipp
│ │ │ │ │ │ ├── basic_binary_iarchive.ipp
│ │ │ │ │ │ ├── basic_binary_iprimitive.ipp
│ │ │ │ │ │ ├── basic_binary_oarchive.ipp
│ │ │ │ │ │ ├── basic_binary_oprimitive.ipp
│ │ │ │ │ │ ├── basic_text_iarchive.ipp
│ │ │ │ │ │ ├── basic_text_iprimitive.ipp
│ │ │ │ │ │ ├── basic_text_oarchive.ipp
│ │ │ │ │ │ ├── basic_text_oprimitive.ipp
│ │ │ │ │ │ ├── basic_xml_grammar.hpp
│ │ │ │ │ │ ├── basic_xml_iarchive.ipp
│ │ │ │ │ │ ├── basic_xml_oarchive.ipp
│ │ │ │ │ │ ├── text_iarchive_impl.ipp
│ │ │ │ │ │ ├── text_oarchive_impl.ipp
│ │ │ │ │ │ ├── text_wiarchive_impl.ipp
│ │ │ │ │ │ ├── text_woarchive_impl.ipp
│ │ │ │ │ │ ├── xml_iarchive_impl.ipp
│ │ │ │ │ │ ├── xml_oarchive_impl.ipp
│ │ │ │ │ │ ├── xml_wiarchive_impl.ipp
│ │ │ │ │ │ └── xml_woarchive_impl.ipp
│ │ │ │ │ ├── iterators/
│ │ │ │ │ │ ├── base64_exception.hpp
│ │ │ │ │ │ ├── base64_from_binary.hpp
│ │ │ │ │ │ ├── binary_from_base64.hpp
│ │ │ │ │ │ ├── dataflow.hpp
│ │ │ │ │ │ ├── dataflow_exception.hpp
│ │ │ │ │ │ ├── escape.hpp
│ │ │ │ │ │ ├── head_iterator.hpp
│ │ │ │ │ │ ├── insert_linebreaks.hpp
│ │ │ │ │ │ ├── istream_iterator.hpp
│ │ │ │ │ │ ├── mb_from_wchar.hpp
│ │ │ │ │ │ ├── ostream_iterator.hpp
│ │ │ │ │ │ ├── remove_whitespace.hpp
│ │ │ │ │ │ ├── transform_width.hpp
│ │ │ │ │ │ ├── unescape.hpp
│ │ │ │ │ │ ├── wchar_from_mb.hpp
│ │ │ │ │ │ ├── xml_escape.hpp
│ │ │ │ │ │ ├── xml_unescape.hpp
│ │ │ │ │ │ └── xml_unescape_exception.hpp
│ │ │ │ │ ├── polymorphic_binary_iarchive.hpp
│ │ │ │ │ ├── polymorphic_binary_oarchive.hpp
│ │ │ │ │ ├── polymorphic_iarchive.hpp
│ │ │ │ │ ├── polymorphic_oarchive.hpp
│ │ │ │ │ ├── polymorphic_text_iarchive.hpp
│ │ │ │ │ ├── polymorphic_text_oarchive.hpp
│ │ │ │ │ ├── polymorphic_text_wiarchive.hpp
│ │ │ │ │ ├── polymorphic_text_woarchive.hpp
│ │ │ │ │ ├── polymorphic_xml_iarchive.hpp
│ │ │ │ │ ├── polymorphic_xml_oarchive.hpp
│ │ │ │ │ ├── polymorphic_xml_wiarchive.hpp
│ │ │ │ │ ├── polymorphic_xml_woarchive.hpp
│ │ │ │ │ ├── shared_ptr_helper.hpp
│ │ │ │ │ ├── text_iarchive.hpp
│ │ │ │ │ ├── text_oarchive.hpp
│ │ │ │ │ ├── text_wiarchive.hpp
│ │ │ │ │ ├── text_woarchive.hpp
│ │ │ │ │ ├── tmpdir.hpp
│ │ │ │ │ ├── wcslen.hpp
│ │ │ │ │ ├── xml_archive_exception.hpp
│ │ │ │ │ ├── xml_iarchive.hpp
│ │ │ │ │ ├── xml_oarchive.hpp
│ │ │ │ │ ├── xml_wiarchive.hpp
│ │ │ │ │ └── xml_woarchive.hpp
│ │ │ │ ├── array.hpp
│ │ │ │ ├── asio/
│ │ │ │ │ ├── async_result.hpp
│ │ │ │ │ ├── basic_datagram_socket.hpp
│ │ │ │ │ ├── basic_deadline_timer.hpp
│ │ │ │ │ ├── basic_io_object.hpp
│ │ │ │ │ ├── basic_raw_socket.hpp
│ │ │ │ │ ├── basic_seq_packet_socket.hpp
│ │ │ │ │ ├── basic_serial_port.hpp
│ │ │ │ │ ├── basic_signal_set.hpp
│ │ │ │ │ ├── basic_socket.hpp
│ │ │ │ │ ├── basic_socket_acceptor.hpp
│ │ │ │ │ ├── basic_socket_iostream.hpp
│ │ │ │ │ ├── basic_socket_streambuf.hpp
│ │ │ │ │ ├── basic_stream_socket.hpp
│ │ │ │ │ ├── basic_streambuf.hpp
│ │ │ │ │ ├── basic_streambuf_fwd.hpp
│ │ │ │ │ ├── basic_waitable_timer.hpp
│ │ │ │ │ ├── buffer.hpp
│ │ │ │ │ ├── buffered_read_stream.hpp
│ │ │ │ │ ├── buffered_read_stream_fwd.hpp
│ │ │ │ │ ├── buffered_stream.hpp
│ │ │ │ │ ├── buffered_stream_fwd.hpp
│ │ │ │ │ ├── buffered_write_stream.hpp
│ │ │ │ │ ├── buffered_write_stream_fwd.hpp
│ │ │ │ │ ├── buffers_iterator.hpp
│ │ │ │ │ ├── completion_condition.hpp
│ │ │ │ │ ├── connect.hpp
│ │ │ │ │ ├── coroutine.hpp
│ │ │ │ │ ├── datagram_socket_service.hpp
│ │ │ │ │ ├── deadline_timer.hpp
│ │ │ │ │ ├── deadline_timer_service.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── addressof.hpp
│ │ │ │ │ │ ├── array.hpp
│ │ │ │ │ │ ├── array_fwd.hpp
│ │ │ │ │ │ ├── assert.hpp
│ │ │ │ │ │ ├── atomic_count.hpp
│ │ │ │ │ │ ├── base_from_completion_cond.hpp
│ │ │ │ │ │ ├── bind_handler.hpp
│ │ │ │ │ │ ├── buffer_resize_guard.hpp
│ │ │ │ │ │ ├── buffer_sequence_adapter.hpp
│ │ │ │ │ │ ├── buffered_stream_storage.hpp
│ │ │ │ │ │ ├── call_stack.hpp
│ │ │ │ │ │ ├── chrono_time_traits.hpp
│ │ │ │ │ │ ├── completion_handler.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── consuming_buffers.hpp
│ │ │ │ │ │ ├── cstdint.hpp
│ │ │ │ │ │ ├── date_time_fwd.hpp
│ │ │ │ │ │ ├── deadline_timer_service.hpp
│ │ │ │ │ │ ├── dependent_type.hpp
│ │ │ │ │ │ ├── descriptor_ops.hpp
│ │ │ │ │ │ ├── descriptor_read_op.hpp
│ │ │ │ │ │ ├── descriptor_write_op.hpp
│ │ │ │ │ │ ├── dev_poll_reactor.hpp
│ │ │ │ │ │ ├── epoll_reactor.hpp
│ │ │ │ │ │ ├── event.hpp
│ │ │ │ │ │ ├── eventfd_select_interrupter.hpp
│ │ │ │ │ │ ├── fd_set_adapter.hpp
│ │ │ │ │ │ ├── fenced_block.hpp
│ │ │ │ │ │ ├── function.hpp
│ │ │ │ │ │ ├── gcc_arm_fenced_block.hpp
│ │ │ │ │ │ ├── gcc_hppa_fenced_block.hpp
│ │ │ │ │ │ ├── gcc_sync_fenced_block.hpp
│ │ │ │ │ │ ├── gcc_x86_fenced_block.hpp
│ │ │ │ │ │ ├── handler_alloc_helpers.hpp
│ │ │ │ │ │ ├── handler_cont_helpers.hpp
│ │ │ │ │ │ ├── handler_invoke_helpers.hpp
│ │ │ │ │ │ ├── handler_tracking.hpp
│ │ │ │ │ │ ├── handler_type_requirements.hpp
│ │ │ │ │ │ ├── hash_map.hpp
│ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ ├── buffer_sequence_adapter.ipp
│ │ │ │ │ │ │ ├── descriptor_ops.ipp
│ │ │ │ │ │ │ ├── dev_poll_reactor.hpp
│ │ │ │ │ │ │ ├── dev_poll_reactor.ipp
│ │ │ │ │ │ │ ├── epoll_reactor.hpp
│ │ │ │ │ │ │ ├── epoll_reactor.ipp
│ │ │ │ │ │ │ ├── eventfd_select_interrupter.ipp
│ │ │ │ │ │ │ ├── handler_tracking.ipp
│ │ │ │ │ │ │ ├── kqueue_reactor.hpp
│ │ │ │ │ │ │ ├── kqueue_reactor.ipp
│ │ │ │ │ │ │ ├── pipe_select_interrupter.ipp
│ │ │ │ │ │ │ ├── posix_event.ipp
│ │ │ │ │ │ │ ├── posix_mutex.ipp
│ │ │ │ │ │ │ ├── posix_thread.ipp
│ │ │ │ │ │ │ ├── posix_tss_ptr.ipp
│ │ │ │ │ │ │ ├── reactive_descriptor_service.ipp
│ │ │ │ │ │ │ ├── reactive_serial_port_service.ipp
│ │ │ │ │ │ │ ├── reactive_socket_service_base.ipp
│ │ │ │ │ │ │ ├── resolver_service_base.ipp
│ │ │ │ │ │ │ ├── select_reactor.hpp
│ │ │ │ │ │ │ ├── select_reactor.ipp
│ │ │ │ │ │ │ ├── service_registry.hpp
│ │ │ │ │ │ │ ├── service_registry.ipp
│ │ │ │ │ │ │ ├── signal_set_service.ipp
│ │ │ │ │ │ │ ├── socket_ops.ipp
│ │ │ │ │ │ │ ├── socket_select_interrupter.ipp
│ │ │ │ │ │ │ ├── strand_service.hpp
│ │ │ │ │ │ │ ├── strand_service.ipp
│ │ │ │ │ │ │ ├── task_io_service.hpp
│ │ │ │ │ │ │ ├── task_io_service.ipp
│ │ │ │ │ │ │ ├── throw_error.ipp
│ │ │ │ │ │ │ ├── timer_queue_ptime.ipp
│ │ │ │ │ │ │ ├── timer_queue_set.ipp
│ │ │ │ │ │ │ ├── win_event.ipp
│ │ │ │ │ │ │ ├── win_iocp_handle_service.ipp
│ │ │ │ │ │ │ ├── win_iocp_io_service.hpp
│ │ │ │ │ │ │ ├── win_iocp_io_service.ipp
│ │ │ │ │ │ │ ├── win_iocp_serial_port_service.ipp
│ │ │ │ │ │ │ ├── win_iocp_socket_service_base.ipp
│ │ │ │ │ │ │ ├── win_mutex.ipp
│ │ │ │ │ │ │ ├── win_object_handle_service.ipp
│ │ │ │ │ │ │ ├── win_static_mutex.ipp
│ │ │ │ │ │ │ ├── win_thread.ipp
│ │ │ │ │ │ │ ├── win_tss_ptr.ipp
│ │ │ │ │ │ │ ├── winrt_ssocket_service_base.ipp
│ │ │ │ │ │ │ ├── winrt_timer_scheduler.hpp
│ │ │ │ │ │ │ ├── winrt_timer_scheduler.ipp
│ │ │ │ │ │ │ └── winsock_init.ipp
│ │ │ │ │ │ ├── io_control.hpp
│ │ │ │ │ │ ├── keyword_tss_ptr.hpp
│ │ │ │ │ │ ├── kqueue_reactor.hpp
│ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ ├── local_free_on_block_exit.hpp
│ │ │ │ │ │ ├── macos_fenced_block.hpp
│ │ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ │ ├── noncopyable.hpp
│ │ │ │ │ │ ├── null_event.hpp
│ │ │ │ │ │ ├── null_fenced_block.hpp
│ │ │ │ │ │ ├── null_mutex.hpp
│ │ │ │ │ │ ├── null_reactor.hpp
│ │ │ │ │ │ ├── null_signal_blocker.hpp
│ │ │ │ │ │ ├── null_socket_service.hpp
│ │ │ │ │ │ ├── null_static_mutex.hpp
│ │ │ │ │ │ ├── null_thread.hpp
│ │ │ │ │ │ ├── null_tss_ptr.hpp
│ │ │ │ │ │ ├── object_pool.hpp
│ │ │ │ │ │ ├── old_win_sdk_compat.hpp
│ │ │ │ │ │ ├── op_queue.hpp
│ │ │ │ │ │ ├── operation.hpp
│ │ │ │ │ │ ├── pipe_select_interrupter.hpp
│ │ │ │ │ │ ├── pop_options.hpp
│ │ │ │ │ │ ├── posix_event.hpp
│ │ │ │ │ │ ├── posix_fd_set_adapter.hpp
│ │ │ │ │ │ ├── posix_mutex.hpp
│ │ │ │ │ │ ├── posix_signal_blocker.hpp
│ │ │ │ │ │ ├── posix_static_mutex.hpp
│ │ │ │ │ │ ├── posix_thread.hpp
│ │ │ │ │ │ ├── posix_tss_ptr.hpp
│ │ │ │ │ │ ├── push_options.hpp
│ │ │ │ │ │ ├── reactive_descriptor_service.hpp
│ │ │ │ │ │ ├── reactive_null_buffers_op.hpp
│ │ │ │ │ │ ├── reactive_serial_port_service.hpp
│ │ │ │ │ │ ├── reactive_socket_accept_op.hpp
│ │ │ │ │ │ ├── reactive_socket_connect_op.hpp
│ │ │ │ │ │ ├── reactive_socket_recv_op.hpp
│ │ │ │ │ │ ├── reactive_socket_recvfrom_op.hpp
│ │ │ │ │ │ ├── reactive_socket_recvmsg_op.hpp
│ │ │ │ │ │ ├── reactive_socket_send_op.hpp
│ │ │ │ │ │ ├── reactive_socket_sendto_op.hpp
│ │ │ │ │ │ ├── reactive_socket_service.hpp
│ │ │ │ │ │ ├── reactive_socket_service_base.hpp
│ │ │ │ │ │ ├── reactor.hpp
│ │ │ │ │ │ ├── reactor_fwd.hpp
│ │ │ │ │ │ ├── reactor_op.hpp
│ │ │ │ │ │ ├── reactor_op_queue.hpp
│ │ │ │ │ │ ├── regex_fwd.hpp
│ │ │ │ │ │ ├── resolve_endpoint_op.hpp
│ │ │ │ │ │ ├── resolve_op.hpp
│ │ │ │ │ │ ├── resolver_service.hpp
│ │ │ │ │ │ ├── resolver_service_base.hpp
│ │ │ │ │ │ ├── scoped_lock.hpp
│ │ │ │ │ │ ├── scoped_ptr.hpp
│ │ │ │ │ │ ├── select_interrupter.hpp
│ │ │ │ │ │ ├── select_reactor.hpp
│ │ │ │ │ │ ├── service_registry.hpp
│ │ │ │ │ │ ├── shared_ptr.hpp
│ │ │ │ │ │ ├── signal_blocker.hpp
│ │ │ │ │ │ ├── signal_handler.hpp
│ │ │ │ │ │ ├── signal_init.hpp
│ │ │ │ │ │ ├── signal_op.hpp
│ │ │ │ │ │ ├── signal_set_service.hpp
│ │ │ │ │ │ ├── socket_holder.hpp
│ │ │ │ │ │ ├── socket_ops.hpp
│ │ │ │ │ │ ├── socket_option.hpp
│ │ │ │ │ │ ├── socket_select_interrupter.hpp
│ │ │ │ │ │ ├── socket_types.hpp
│ │ │ │ │ │ ├── solaris_fenced_block.hpp
│ │ │ │ │ │ ├── static_mutex.hpp
│ │ │ │ │ │ ├── std_event.hpp
│ │ │ │ │ │ ├── std_mutex.hpp
│ │ │ │ │ │ ├── std_static_mutex.hpp
│ │ │ │ │ │ ├── std_thread.hpp
│ │ │ │ │ │ ├── strand_service.hpp
│ │ │ │ │ │ ├── task_io_service.hpp
│ │ │ │ │ │ ├── task_io_service_operation.hpp
│ │ │ │ │ │ ├── task_io_service_thread_info.hpp
│ │ │ │ │ │ ├── thread.hpp
│ │ │ │ │ │ ├── thread_info_base.hpp
│ │ │ │ │ │ ├── throw_error.hpp
│ │ │ │ │ │ ├── throw_exception.hpp
│ │ │ │ │ │ ├── timer_queue.hpp
│ │ │ │ │ │ ├── timer_queue_base.hpp
│ │ │ │ │ │ ├── timer_queue_ptime.hpp
│ │ │ │ │ │ ├── timer_queue_set.hpp
│ │ │ │ │ │ ├── timer_scheduler.hpp
│ │ │ │ │ │ ├── timer_scheduler_fwd.hpp
│ │ │ │ │ │ ├── tss_ptr.hpp
│ │ │ │ │ │ ├── type_traits.hpp
│ │ │ │ │ │ ├── variadic_templates.hpp
│ │ │ │ │ │ ├── wait_handler.hpp
│ │ │ │ │ │ ├── wait_op.hpp
│ │ │ │ │ │ ├── weak_ptr.hpp
│ │ │ │ │ │ ├── win_event.hpp
│ │ │ │ │ │ ├── win_fd_set_adapter.hpp
│ │ │ │ │ │ ├── win_fenced_block.hpp
│ │ │ │ │ │ ├── win_iocp_handle_read_op.hpp
│ │ │ │ │ │ ├── win_iocp_handle_service.hpp
│ │ │ │ │ │ ├── win_iocp_handle_write_op.hpp
│ │ │ │ │ │ ├── win_iocp_io_service.hpp
│ │ │ │ │ │ ├── win_iocp_null_buffers_op.hpp
│ │ │ │ │ │ ├── win_iocp_operation.hpp
│ │ │ │ │ │ ├── win_iocp_overlapped_op.hpp
│ │ │ │ │ │ ├── win_iocp_overlapped_ptr.hpp
│ │ │ │ │ │ ├── win_iocp_serial_port_service.hpp
│ │ │ │ │ │ ├── win_iocp_socket_accept_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_connect_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_recv_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_recvfrom_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_recvmsg_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_send_op.hpp
│ │ │ │ │ │ ├── win_iocp_socket_service.hpp
│ │ │ │ │ │ ├── win_iocp_socket_service_base.hpp
│ │ │ │ │ │ ├── win_iocp_thread_info.hpp
│ │ │ │ │ │ ├── win_mutex.hpp
│ │ │ │ │ │ ├── win_object_handle_service.hpp
│ │ │ │ │ │ ├── win_static_mutex.hpp
│ │ │ │ │ │ ├── win_thread.hpp
│ │ │ │ │ │ ├── win_tss_ptr.hpp
│ │ │ │ │ │ ├── winapi_thread.hpp
│ │ │ │ │ │ ├── wince_thread.hpp
│ │ │ │ │ │ ├── winrt_async_manager.hpp
│ │ │ │ │ │ ├── winrt_async_op.hpp
│ │ │ │ │ │ ├── winrt_resolve_op.hpp
│ │ │ │ │ │ ├── winrt_resolver_service.hpp
│ │ │ │ │ │ ├── winrt_socket_connect_op.hpp
│ │ │ │ │ │ ├── winrt_socket_recv_op.hpp
│ │ │ │ │ │ ├── winrt_socket_send_op.hpp
│ │ │ │ │ │ ├── winrt_ssocket_service.hpp
│ │ │ │ │ │ ├── winrt_ssocket_service_base.hpp
│ │ │ │ │ │ ├── winrt_timer_scheduler.hpp
│ │ │ │ │ │ ├── winrt_utils.hpp
│ │ │ │ │ │ ├── winsock_init.hpp
│ │ │ │ │ │ └── wrapped_handler.hpp
│ │ │ │ │ ├── error.hpp
│ │ │ │ │ ├── generic/
│ │ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ │ ├── datagram_protocol.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ │ │ └── impl/
│ │ │ │ │ │ │ └── endpoint.ipp
│ │ │ │ │ │ ├── raw_protocol.hpp
│ │ │ │ │ │ ├── seq_packet_protocol.hpp
│ │ │ │ │ │ └── stream_protocol.hpp
│ │ │ │ │ ├── handler_alloc_hook.hpp
│ │ │ │ │ ├── handler_continuation_hook.hpp
│ │ │ │ │ ├── handler_invoke_hook.hpp
│ │ │ │ │ ├── handler_type.hpp
│ │ │ │ │ ├── high_resolution_timer.hpp
│ │ │ │ │ ├── impl/
│ │ │ │ │ │ ├── buffered_read_stream.hpp
│ │ │ │ │ │ ├── buffered_write_stream.hpp
│ │ │ │ │ │ ├── connect.hpp
│ │ │ │ │ │ ├── error.ipp
│ │ │ │ │ │ ├── handler_alloc_hook.ipp
│ │ │ │ │ │ ├── io_service.hpp
│ │ │ │ │ │ ├── io_service.ipp
│ │ │ │ │ │ ├── read.hpp
│ │ │ │ │ │ ├── read_at.hpp
│ │ │ │ │ │ ├── read_until.hpp
│ │ │ │ │ │ ├── serial_port_base.hpp
│ │ │ │ │ │ ├── serial_port_base.ipp
│ │ │ │ │ │ ├── spawn.hpp
│ │ │ │ │ │ ├── src.cpp
│ │ │ │ │ │ ├── src.hpp
│ │ │ │ │ │ ├── use_future.hpp
│ │ │ │ │ │ ├── write.hpp
│ │ │ │ │ │ └── write_at.hpp
│ │ │ │ │ ├── io_service.hpp
│ │ │ │ │ ├── ip/
│ │ │ │ │ │ ├── address.hpp
│ │ │ │ │ │ ├── address_v4.hpp
│ │ │ │ │ │ ├── address_v6.hpp
│ │ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ │ ├── basic_resolver.hpp
│ │ │ │ │ │ ├── basic_resolver_entry.hpp
│ │ │ │ │ │ ├── basic_resolver_iterator.hpp
│ │ │ │ │ │ ├── basic_resolver_query.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ │ └── endpoint.ipp
│ │ │ │ │ │ │ └── socket_option.hpp
│ │ │ │ │ │ ├── host_name.hpp
│ │ │ │ │ │ ├── icmp.hpp
│ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ ├── address.hpp
│ │ │ │ │ │ │ ├── address.ipp
│ │ │ │ │ │ │ ├── address_v4.hpp
│ │ │ │ │ │ │ ├── address_v4.ipp
│ │ │ │ │ │ │ ├── address_v6.hpp
│ │ │ │ │ │ │ ├── address_v6.ipp
│ │ │ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ │ │ └── host_name.ipp
│ │ │ │ │ │ ├── multicast.hpp
│ │ │ │ │ │ ├── resolver_query_base.hpp
│ │ │ │ │ │ ├── resolver_service.hpp
│ │ │ │ │ │ ├── tcp.hpp
│ │ │ │ │ │ ├── udp.hpp
│ │ │ │ │ │ ├── unicast.hpp
│ │ │ │ │ │ └── v6_only.hpp
│ │ │ │ │ ├── is_read_buffered.hpp
│ │ │ │ │ ├── is_write_buffered.hpp
│ │ │ │ │ ├── local/
│ │ │ │ │ │ ├── basic_endpoint.hpp
│ │ │ │ │ │ ├── connect_pair.hpp
│ │ │ │ │ │ ├── datagram_protocol.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── endpoint.hpp
│ │ │ │ │ │ │ └── impl/
│ │ │ │ │ │ │ └── endpoint.ipp
│ │ │ │ │ │ └── stream_protocol.hpp
│ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ ├── posix/
│ │ │ │ │ │ ├── basic_descriptor.hpp
│ │ │ │ │ │ ├── basic_stream_descriptor.hpp
│ │ │ │ │ │ ├── descriptor_base.hpp
│ │ │ │ │ │ ├── stream_descriptor.hpp
│ │ │ │ │ │ └── stream_descriptor_service.hpp
│ │ │ │ │ ├── raw_socket_service.hpp
│ │ │ │ │ ├── read.hpp
│ │ │ │ │ ├── read_at.hpp
│ │ │ │ │ ├── read_until.hpp
│ │ │ │ │ ├── seq_packet_socket_service.hpp
│ │ │ │ │ ├── serial_port.hpp
│ │ │ │ │ ├── serial_port_base.hpp
│ │ │ │ │ ├── serial_port_service.hpp
│ │ │ │ │ ├── signal_set.hpp
│ │ │ │ │ ├── signal_set_service.hpp
│ │ │ │ │ ├── socket_acceptor_service.hpp
│ │ │ │ │ ├── socket_base.hpp
│ │ │ │ │ ├── spawn.hpp
│ │ │ │ │ ├── ssl/
│ │ │ │ │ │ ├── basic_context.hpp
│ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ ├── context_base.hpp
│ │ │ │ │ │ ├── context_service.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── buffered_handshake_op.hpp
│ │ │ │ │ │ │ ├── engine.hpp
│ │ │ │ │ │ │ ├── handshake_op.hpp
│ │ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ │ ├── engine.ipp
│ │ │ │ │ │ │ │ └── openssl_init.ipp
│ │ │ │ │ │ │ ├── io.hpp
│ │ │ │ │ │ │ ├── openssl_init.hpp
│ │ │ │ │ │ │ ├── openssl_types.hpp
│ │ │ │ │ │ │ ├── password_callback.hpp
│ │ │ │ │ │ │ ├── read_op.hpp
│ │ │ │ │ │ │ ├── shutdown_op.hpp
│ │ │ │ │ │ │ ├── stream_core.hpp
│ │ │ │ │ │ │ ├── verify_callback.hpp
│ │ │ │ │ │ │ └── write_op.hpp
│ │ │ │ │ │ ├── error.hpp
│ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ │ ├── context.ipp
│ │ │ │ │ │ │ ├── error.ipp
│ │ │ │ │ │ │ ├── rfc2818_verification.ipp
│ │ │ │ │ │ │ └── src.hpp
│ │ │ │ │ │ ├── old/
│ │ │ │ │ │ │ ├── basic_context.hpp
│ │ │ │ │ │ │ ├── context_service.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── openssl_context_service.hpp
│ │ │ │ │ │ │ │ ├── openssl_operation.hpp
│ │ │ │ │ │ │ │ └── openssl_stream_service.hpp
│ │ │ │ │ │ │ ├── stream.hpp
│ │ │ │ │ │ │ └── stream_service.hpp
│ │ │ │ │ │ ├── rfc2818_verification.hpp
│ │ │ │ │ │ ├── stream.hpp
│ │ │ │ │ │ ├── stream_base.hpp
│ │ │ │ │ │ ├── stream_service.hpp
│ │ │ │ │ │ ├── verify_context.hpp
│ │ │ │ │ │ └── verify_mode.hpp
│ │ │ │ │ ├── ssl.hpp
│ │ │ │ │ ├── steady_timer.hpp
│ │ │ │ │ ├── strand.hpp
│ │ │ │ │ ├── stream_socket_service.hpp
│ │ │ │ │ ├── streambuf.hpp
│ │ │ │ │ ├── system_timer.hpp
│ │ │ │ │ ├── time_traits.hpp
│ │ │ │ │ ├── unyield.hpp
│ │ │ │ │ ├── use_future.hpp
│ │ │ │ │ ├── version.hpp
│ │ │ │ │ ├── wait_traits.hpp
│ │ │ │ │ ├── waitable_timer_service.hpp
│ │ │ │ │ ├── windows/
│ │ │ │ │ │ ├── basic_handle.hpp
│ │ │ │ │ │ ├── basic_object_handle.hpp
│ │ │ │ │ │ ├── basic_random_access_handle.hpp
│ │ │ │ │ │ ├── basic_stream_handle.hpp
│ │ │ │ │ │ ├── object_handle.hpp
│ │ │ │ │ │ ├── object_handle_service.hpp
│ │ │ │ │ │ ├── overlapped_ptr.hpp
│ │ │ │ │ │ ├── random_access_handle.hpp
│ │ │ │ │ │ ├── random_access_handle_service.hpp
│ │ │ │ │ │ ├── stream_handle.hpp
│ │ │ │ │ │ └── stream_handle_service.hpp
│ │ │ │ │ ├── write.hpp
│ │ │ │ │ ├── write_at.hpp
│ │ │ │ │ └── yield.hpp
│ │ │ │ ├── asio.hpp
│ │ │ │ ├── assert.hpp
│ │ │ │ ├── assign/
│ │ │ │ │ ├── assignment_exception.hpp
│ │ │ │ │ ├── list_inserter.hpp
│ │ │ │ │ ├── list_of.hpp
│ │ │ │ │ ├── ptr_list_inserter.hpp
│ │ │ │ │ ├── ptr_list_of.hpp
│ │ │ │ │ ├── ptr_map_inserter.hpp
│ │ │ │ │ ├── std/
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── queue.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── slist.hpp
│ │ │ │ │ │ ├── stack.hpp
│ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ └── std.hpp
│ │ │ │ ├── assign.hpp
│ │ │ │ ├── atomic/
│ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ ├── atomic_flag.hpp
│ │ │ │ │ ├── capabilities.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── atomic_flag.hpp
│ │ │ │ │ │ ├── atomic_template.hpp
│ │ │ │ │ │ ├── bitwise_cast.hpp
│ │ │ │ │ │ ├── caps_gcc_alpha.hpp
│ │ │ │ │ │ ├── caps_gcc_arm.hpp
│ │ │ │ │ │ ├── caps_gcc_atomic.hpp
│ │ │ │ │ │ ├── caps_gcc_ppc.hpp
│ │ │ │ │ │ ├── caps_gcc_sparc.hpp
│ │ │ │ │ │ ├── caps_gcc_sync.hpp
│ │ │ │ │ │ ├── caps_gcc_x86.hpp
│ │ │ │ │ │ ├── caps_linux_arm.hpp
│ │ │ │ │ │ ├── caps_msvc_arm.hpp
│ │ │ │ │ │ ├── caps_msvc_x86.hpp
│ │ │ │ │ │ ├── caps_windows.hpp
│ │ │ │ │ │ ├── casts.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── int_sizes.hpp
│ │ │ │ │ │ ├── interlocked.hpp
│ │ │ │ │ │ ├── link.hpp
│ │ │ │ │ │ ├── lockpool.hpp
│ │ │ │ │ │ ├── operations.hpp
│ │ │ │ │ │ ├── operations_fwd.hpp
│ │ │ │ │ │ ├── operations_lockfree.hpp
│ │ │ │ │ │ ├── ops_cas_based.hpp
│ │ │ │ │ │ ├── ops_emulated.hpp
│ │ │ │ │ │ ├── ops_extending_cas_based.hpp
│ │ │ │ │ │ ├── ops_gcc_alpha.hpp
│ │ │ │ │ │ ├── ops_gcc_arm.hpp
│ │ │ │ │ │ ├── ops_gcc_atomic.hpp
│ │ │ │ │ │ ├── ops_gcc_ppc.hpp
│ │ │ │ │ │ ├── ops_gcc_sparc.hpp
│ │ │ │ │ │ ├── ops_gcc_sync.hpp
│ │ │ │ │ │ ├── ops_gcc_x86.hpp
│ │ │ │ │ │ ├── ops_gcc_x86_dcas.hpp
│ │ │ │ │ │ ├── ops_linux_arm.hpp
│ │ │ │ │ │ ├── ops_msvc_arm.hpp
│ │ │ │ │ │ ├── ops_msvc_common.hpp
│ │ │ │ │ │ ├── ops_msvc_x86.hpp
│ │ │ │ │ │ ├── ops_windows.hpp
│ │ │ │ │ │ ├── pause.hpp
│ │ │ │ │ │ ├── platform.hpp
│ │ │ │ │ │ └── storage_type.hpp
│ │ │ │ │ └── fences.hpp
│ │ │ │ ├── atomic.hpp
│ │ │ │ ├── bimap/
│ │ │ │ │ ├── bimap.hpp
│ │ │ │ │ ├── container_adaptor/
│ │ │ │ │ │ ├── associative_container_adaptor.hpp
│ │ │ │ │ │ ├── container_adaptor.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── comparison_adaptor.hpp
│ │ │ │ │ │ │ ├── functor_bag.hpp
│ │ │ │ │ │ │ ├── identity_converters.hpp
│ │ │ │ │ │ │ ├── key_extractor.hpp
│ │ │ │ │ │ │ └── non_unique_container_helper.hpp
│ │ │ │ │ │ ├── list_adaptor.hpp
│ │ │ │ │ │ ├── list_map_adaptor.hpp
│ │ │ │ │ │ ├── map_adaptor.hpp
│ │ │ │ │ │ ├── multimap_adaptor.hpp
│ │ │ │ │ │ ├── multiset_adaptor.hpp
│ │ │ │ │ │ ├── ordered_associative_container_adaptor.hpp
│ │ │ │ │ │ ├── sequence_container_adaptor.hpp
│ │ │ │ │ │ ├── set_adaptor.hpp
│ │ │ │ │ │ ├── support/
│ │ │ │ │ │ │ └── iterator_facade_converters.hpp
│ │ │ │ │ │ ├── unordered_associative_container_adaptor.hpp
│ │ │ │ │ │ ├── unordered_map_adaptor.hpp
│ │ │ │ │ │ ├── unordered_multimap_adaptor.hpp
│ │ │ │ │ │ ├── unordered_multiset_adaptor.hpp
│ │ │ │ │ │ ├── unordered_set_adaptor.hpp
│ │ │ │ │ │ ├── vector_adaptor.hpp
│ │ │ │ │ │ └── vector_map_adaptor.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── bimap_core.hpp
│ │ │ │ │ │ ├── concept_tags.hpp
│ │ │ │ │ │ ├── debug/
│ │ │ │ │ │ │ └── static_error.hpp
│ │ │ │ │ │ ├── generate_index_binder.hpp
│ │ │ │ │ │ ├── generate_relation_binder.hpp
│ │ │ │ │ │ ├── generate_view_binder.hpp
│ │ │ │ │ │ ├── is_set_type_of.hpp
│ │ │ │ │ │ ├── manage_additional_parameters.hpp
│ │ │ │ │ │ ├── manage_bimap_key.hpp
│ │ │ │ │ │ ├── map_view_base.hpp
│ │ │ │ │ │ ├── map_view_iterator.hpp
│ │ │ │ │ │ ├── modifier_adaptor.hpp
│ │ │ │ │ │ ├── non_unique_views_helper.hpp
│ │ │ │ │ │ ├── set_view_base.hpp
│ │ │ │ │ │ ├── set_view_iterator.hpp
│ │ │ │ │ │ ├── test/
│ │ │ │ │ │ │ └── check_metadata.hpp
│ │ │ │ │ │ └── user_interface_config.hpp
│ │ │ │ │ ├── list_of.hpp
│ │ │ │ │ ├── multiset_of.hpp
│ │ │ │ │ ├── property_map/
│ │ │ │ │ │ ├── set_support.hpp
│ │ │ │ │ │ └── unordered_set_support.hpp
│ │ │ │ │ ├── relation/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── access_builder.hpp
│ │ │ │ │ │ │ ├── metadata_access_builder.hpp
│ │ │ │ │ │ │ ├── mutant.hpp
│ │ │ │ │ │ │ ├── static_access_builder.hpp
│ │ │ │ │ │ │ └── to_mutable_relation_functor.hpp
│ │ │ │ │ │ ├── member_at.hpp
│ │ │ │ │ │ ├── mutant_relation.hpp
│ │ │ │ │ │ ├── pair_layout.hpp
│ │ │ │ │ │ ├── structured_pair.hpp
│ │ │ │ │ │ ├── support/
│ │ │ │ │ │ │ ├── data_extractor.hpp
│ │ │ │ │ │ │ ├── get.hpp
│ │ │ │ │ │ │ ├── get_pair_functor.hpp
│ │ │ │ │ │ │ ├── is_tag_of_member_at.hpp
│ │ │ │ │ │ │ ├── member_with_tag.hpp
│ │ │ │ │ │ │ ├── opposite_tag.hpp
│ │ │ │ │ │ │ ├── pair_by.hpp
│ │ │ │ │ │ │ ├── pair_type_by.hpp
│ │ │ │ │ │ │ └── value_type_of.hpp
│ │ │ │ │ │ └── symmetrical_base.hpp
│ │ │ │ │ ├── set_of.hpp
│ │ │ │ │ ├── support/
│ │ │ │ │ │ ├── data_type_by.hpp
│ │ │ │ │ │ ├── iterator_type_by.hpp
│ │ │ │ │ │ ├── key_type_by.hpp
│ │ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ │ ├── map_by.hpp
│ │ │ │ │ │ ├── map_type_by.hpp
│ │ │ │ │ │ └── value_type_by.hpp
│ │ │ │ │ ├── tags/
│ │ │ │ │ │ ├── support/
│ │ │ │ │ │ │ ├── apply_to_value_type.hpp
│ │ │ │ │ │ │ ├── default_tagged.hpp
│ │ │ │ │ │ │ ├── is_tagged.hpp
│ │ │ │ │ │ │ ├── overwrite_tagged.hpp
│ │ │ │ │ │ │ ├── tag_of.hpp
│ │ │ │ │ │ │ └── value_type_of.hpp
│ │ │ │ │ │ └── tagged.hpp
│ │ │ │ │ ├── unconstrained_set_of.hpp
│ │ │ │ │ ├── unordered_multiset_of.hpp
│ │ │ │ │ ├── unordered_set_of.hpp
│ │ │ │ │ ├── vector_of.hpp
│ │ │ │ │ └── views/
│ │ │ │ │ ├── list_map_view.hpp
│ │ │ │ │ ├── list_set_view.hpp
│ │ │ │ │ ├── map_view.hpp
│ │ │ │ │ ├── multimap_view.hpp
│ │ │ │ │ ├── multiset_view.hpp
│ │ │ │ │ ├── set_view.hpp
│ │ │ │ │ ├── unconstrained_map_view.hpp
│ │ │ │ │ ├── unconstrained_set_view.hpp
│ │ │ │ │ ├── unordered_map_view.hpp
│ │ │ │ │ ├── unordered_multimap_view.hpp
│ │ │ │ │ ├── unordered_multiset_view.hpp
│ │ │ │ │ ├── unordered_set_view.hpp
│ │ │ │ │ ├── vector_map_view.hpp
│ │ │ │ │ └── vector_set_view.hpp
│ │ │ │ ├── bimap.hpp
│ │ │ │ ├── bind/
│ │ │ │ │ ├── apply.hpp
│ │ │ │ │ ├── arg.hpp
│ │ │ │ │ ├── bind.hpp
│ │ │ │ │ ├── bind_cc.hpp
│ │ │ │ │ ├── bind_mf2_cc.hpp
│ │ │ │ │ ├── bind_mf_cc.hpp
│ │ │ │ │ ├── bind_template.hpp
│ │ │ │ │ ├── make_adaptable.hpp
│ │ │ │ │ ├── mem_fn.hpp
│ │ │ │ │ ├── mem_fn_cc.hpp
│ │ │ │ │ ├── mem_fn_template.hpp
│ │ │ │ │ ├── mem_fn_vw.hpp
│ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ ├── protect.hpp
│ │ │ │ │ └── storage.hpp
│ │ │ │ ├── bind.hpp
│ │ │ │ ├── blank.hpp
│ │ │ │ ├── blank_fwd.hpp
│ │ │ │ ├── call_traits.hpp
│ │ │ │ ├── cast.hpp
│ │ │ │ ├── cerrno.hpp
│ │ │ │ ├── checked_delete.hpp
│ │ │ │ ├── chrono/
│ │ │ │ │ ├── ceil.hpp
│ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ ├── chrono_io.hpp
│ │ │ │ │ ├── clock_string.hpp
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── inlined/
│ │ │ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ │ │ ├── mac/
│ │ │ │ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ │ │ │ └── thread_clock.hpp
│ │ │ │ │ │ │ ├── posix/
│ │ │ │ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ │ │ │ └── thread_clock.hpp
│ │ │ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ │ │ ├── thread_clock.hpp
│ │ │ │ │ │ │ └── win/
│ │ │ │ │ │ │ ├── chrono.hpp
│ │ │ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ │ │ └── thread_clock.hpp
│ │ │ │ │ │ ├── is_evenly_divisible_by.hpp
│ │ │ │ │ │ ├── no_warning/
│ │ │ │ │ │ │ └── signed_unsigned_cmp.hpp
│ │ │ │ │ │ ├── scan_keyword.hpp
│ │ │ │ │ │ ├── static_assert.hpp
│ │ │ │ │ │ └── system.hpp
│ │ │ │ │ ├── duration.hpp
│ │ │ │ │ ├── floor.hpp
│ │ │ │ │ ├── include.hpp
│ │ │ │ │ ├── io/
│ │ │ │ │ │ ├── duration_get.hpp
│ │ │ │ │ │ ├── duration_io.hpp
│ │ │ │ │ │ ├── duration_put.hpp
│ │ │ │ │ │ ├── duration_style.hpp
│ │ │ │ │ │ ├── duration_units.hpp
│ │ │ │ │ │ ├── ios_base_state.hpp
│ │ │ │ │ │ ├── time_point_get.hpp
│ │ │ │ │ │ ├── time_point_io.hpp
│ │ │ │ │ │ ├── time_point_put.hpp
│ │ │ │ │ │ ├── time_point_units.hpp
│ │ │ │ │ │ ├── timezone.hpp
│ │ │ │ │ │ └── utility/
│ │ │ │ │ │ ├── ios_base_state_ptr.hpp
│ │ │ │ │ │ ├── manip_base.hpp
│ │ │ │ │ │ └── to_string.hpp
│ │ │ │ │ ├── io_v1/
│ │ │ │ │ │ └── chrono_io.hpp
│ │ │ │ │ ├── process_cpu_clocks.hpp
│ │ │ │ │ ├── round.hpp
│ │ │ │ │ ├── system_clocks.hpp
│ │ │ │ │ ├── thread_clock.hpp
│ │ │ │ │ ├── time_point.hpp
│ │ │ │ │ └── typeof/
│ │ │ │ │ └── boost/
│ │ │ │ │ ├── chrono/
│ │ │ │ │ │ └── chrono.hpp
│ │ │ │ │ └── ratio.hpp
│ │ │ │ ├── chrono.hpp
│ │ │ │ ├── circular_buffer/
│ │ │ │ │ ├── base.hpp
│ │ │ │ │ ├── debug.hpp
│ │ │ │ │ ├── details.hpp
│ │ │ │ │ └── space_optimized.hpp
│ │ │ │ ├── circular_buffer.hpp
│ │ │ │ ├── circular_buffer_fwd.hpp
│ │ │ │ ├── compatibility/
│ │ │ │ │ └── cpp_c_headers/
│ │ │ │ │ ├── cassert
│ │ │ │ │ ├── cctype
│ │ │ │ │ ├── cerrno
│ │ │ │ │ ├── cfloat
│ │ │ │ │ ├── climits
│ │ │ │ │ ├── clocale
│ │ │ │ │ ├── cmath
│ │ │ │ │ ├── csetjmp
│ │ │ │ │ ├── csignal
│ │ │ │ │ ├── cstdarg
│ │ │ │ │ ├── cstddef
│ │ │ │ │ ├── cstdio
│ │ │ │ │ ├── cstdlib
│ │ │ │ │ ├── cstring
│ │ │ │ │ ├── ctime
│ │ │ │ │ ├── cwchar
│ │ │ │ │ └── cwctype
│ │ │ │ ├── compressed_pair.hpp
│ │ │ │ ├── compute/
│ │ │ │ │ ├── algorithm/
│ │ │ │ │ │ ├── accumulate.hpp
│ │ │ │ │ │ ├── adjacent_difference.hpp
│ │ │ │ │ │ ├── adjacent_find.hpp
│ │ │ │ │ │ ├── all_of.hpp
│ │ │ │ │ │ ├── any_of.hpp
│ │ │ │ │ │ ├── binary_search.hpp
│ │ │ │ │ │ ├── copy.hpp
│ │ │ │ │ │ ├── copy_if.hpp
│ │ │ │ │ │ ├── copy_n.hpp
│ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ ├── count_if.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── balanced_path.hpp
│ │ │ │ │ │ │ ├── binary_find.hpp
│ │ │ │ │ │ │ ├── compact.hpp
│ │ │ │ │ │ │ ├── copy_on_device.hpp
│ │ │ │ │ │ │ ├── copy_to_device.hpp
│ │ │ │ │ │ │ ├── copy_to_host.hpp
│ │ │ │ │ │ │ ├── count_if_with_ballot.hpp
│ │ │ │ │ │ │ ├── count_if_with_reduce.hpp
│ │ │ │ │ │ │ ├── count_if_with_threads.hpp
│ │ │ │ │ │ │ ├── find_extrema.hpp
│ │ │ │ │ │ │ ├── find_extrema_on_cpu.hpp
│ │ │ │ │ │ │ ├── find_extrema_with_atomics.hpp
│ │ │ │ │ │ │ ├── find_extrema_with_reduce.hpp
│ │ │ │ │ │ │ ├── find_if_with_atomics.hpp
│ │ │ │ │ │ │ ├── inplace_reduce.hpp
│ │ │ │ │ │ │ ├── insertion_sort.hpp
│ │ │ │ │ │ │ ├── merge_path.hpp
│ │ │ │ │ │ │ ├── merge_sort_on_cpu.hpp
│ │ │ │ │ │ │ ├── merge_sort_on_gpu.hpp
│ │ │ │ │ │ │ ├── merge_with_merge_path.hpp
│ │ │ │ │ │ │ ├── radix_sort.hpp
│ │ │ │ │ │ │ ├── random_fill.hpp
│ │ │ │ │ │ │ ├── reduce_by_key.hpp
│ │ │ │ │ │ │ ├── reduce_by_key_with_scan.hpp
│ │ │ │ │ │ │ ├── reduce_on_cpu.hpp
│ │ │ │ │ │ │ ├── reduce_on_gpu.hpp
│ │ │ │ │ │ │ ├── scan.hpp
│ │ │ │ │ │ │ ├── scan_on_cpu.hpp
│ │ │ │ │ │ │ ├── scan_on_gpu.hpp
│ │ │ │ │ │ │ ├── search_all.hpp
│ │ │ │ │ │ │ ├── serial_accumulate.hpp
│ │ │ │ │ │ │ ├── serial_count_if.hpp
│ │ │ │ │ │ │ ├── serial_find_extrema.hpp
│ │ │ │ │ │ │ ├── serial_merge.hpp
│ │ │ │ │ │ │ ├── serial_reduce.hpp
│ │ │ │ │ │ │ ├── serial_reduce_by_key.hpp
│ │ │ │ │ │ │ └── serial_scan.hpp
│ │ │ │ │ │ ├── equal.hpp
│ │ │ │ │ │ ├── equal_range.hpp
│ │ │ │ │ │ ├── exclusive_scan.hpp
│ │ │ │ │ │ ├── fill.hpp
│ │ │ │ │ │ ├── fill_n.hpp
│ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ ├── find_end.hpp
│ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ ├── find_if_not.hpp
│ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ ├── for_each_n.hpp
│ │ │ │ │ │ ├── gather.hpp
│ │ │ │ │ │ ├── generate.hpp
│ │ │ │ │ │ ├── generate_n.hpp
│ │ │ │ │ │ ├── includes.hpp
│ │ │ │ │ │ ├── inclusive_scan.hpp
│ │ │ │ │ │ ├── inner_product.hpp
│ │ │ │ │ │ ├── inplace_merge.hpp
│ │ │ │ │ │ ├── iota.hpp
│ │ │ │ │ │ ├── is_partitioned.hpp
│ │ │ │ │ │ ├── is_permutation.hpp
│ │ │ │ │ │ ├── is_sorted.hpp
│ │ │ │ │ │ ├── lexicographical_compare.hpp
│ │ │ │ │ │ ├── lower_bound.hpp
│ │ │ │ │ │ ├── max_element.hpp
│ │ │ │ │ │ ├── merge.hpp
│ │ │ │ │ │ ├── min_element.hpp
│ │ │ │ │ │ ├── minmax_element.hpp
│ │ │ │ │ │ ├── mismatch.hpp
│ │ │ │ │ │ ├── next_permutation.hpp
│ │ │ │ │ │ ├── none_of.hpp
│ │ │ │ │ │ ├── nth_element.hpp
│ │ │ │ │ │ ├── partial_sum.hpp
│ │ │ │ │ │ ├── partition.hpp
│ │ │ │ │ │ ├── partition_copy.hpp
│ │ │ │ │ │ ├── partition_point.hpp
│ │ │ │ │ │ ├── prev_permutation.hpp
│ │ │ │ │ │ ├── random_shuffle.hpp
│ │ │ │ │ │ ├── reduce.hpp
│ │ │ │ │ │ ├── reduce_by_key.hpp
│ │ │ │ │ │ ├── remove.hpp
│ │ │ │ │ │ ├── remove_if.hpp
│ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ ├── replace_copy.hpp
│ │ │ │ │ │ ├── reverse.hpp
│ │ │ │ │ │ ├── reverse_copy.hpp
│ │ │ │ │ │ ├── rotate.hpp
│ │ │ │ │ │ ├── rotate_copy.hpp
│ │ │ │ │ │ ├── scatter.hpp
│ │ │ │ │ │ ├── scatter_if.hpp
│ │ │ │ │ │ ├── search.hpp
│ │ │ │ │ │ ├── search_n.hpp
│ │ │ │ │ │ ├── set_difference.hpp
│ │ │ │ │ │ ├── set_intersection.hpp
│ │ │ │ │ │ ├── set_symmetric_difference.hpp
│ │ │ │ │ │ ├── set_union.hpp
│ │ │ │ │ │ ├── sort.hpp
│ │ │ │ │ │ ├── sort_by_key.hpp
│ │ │ │ │ │ ├── stable_partition.hpp
│ │ │ │ │ │ ├── stable_sort.hpp
│ │ │ │ │ │ ├── stable_sort_by_key.hpp
│ │ │ │ │ │ ├── swap_ranges.hpp
│ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ ├── transform_if.hpp
│ │ │ │ │ │ ├── transform_reduce.hpp
│ │ │ │ │ │ ├── unique.hpp
│ │ │ │ │ │ ├── unique_copy.hpp
│ │ │ │ │ │ └── upper_bound.hpp
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── allocator/
│ │ │ │ │ │ ├── buffer_allocator.hpp
│ │ │ │ │ │ └── pinned_allocator.hpp
│ │ │ │ │ ├── allocator.hpp
│ │ │ │ │ ├── async/
│ │ │ │ │ │ ├── future.hpp
│ │ │ │ │ │ ├── wait.hpp
│ │ │ │ │ │ └── wait_guard.hpp
│ │ │ │ │ ├── async.hpp
│ │ │ │ │ ├── buffer.hpp
│ │ │ │ │ ├── cl.hpp
│ │ │ │ │ ├── cl_ext.hpp
│ │ │ │ │ ├── closure.hpp
│ │ │ │ │ ├── command_queue.hpp
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── container/
│ │ │ │ │ │ ├── array.hpp
│ │ │ │ │ │ ├── basic_string.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── scalar.hpp
│ │ │ │ │ │ ├── dynamic_bitset.hpp
│ │ │ │ │ │ ├── flat_map.hpp
│ │ │ │ │ │ ├── flat_set.hpp
│ │ │ │ │ │ ├── mapped_view.hpp
│ │ │ │ │ │ ├── stack.hpp
│ │ │ │ │ │ ├── string.hpp
│ │ │ │ │ │ ├── valarray.hpp
│ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ ├── container.hpp
│ │ │ │ │ ├── context.hpp
│ │ │ │ │ ├── core.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── assert_cl_success.hpp
│ │ │ │ │ │ ├── buffer_value.hpp
│ │ │ │ │ │ ├── device_ptr.hpp
│ │ │ │ │ │ ├── diagnostic.hpp
│ │ │ │ │ │ ├── duration.hpp
│ │ │ │ │ │ ├── get_object_info.hpp
│ │ │ │ │ │ ├── getenv.hpp
│ │ │ │ │ │ ├── global_static.hpp
│ │ │ │ │ │ ├── is_buffer_iterator.hpp
│ │ │ │ │ │ ├── is_contiguous_iterator.hpp
│ │ │ │ │ │ ├── iterator_plus_distance.hpp
│ │ │ │ │ │ ├── iterator_range_size.hpp
│ │ │ │ │ │ ├── iterator_traits.hpp
│ │ │ │ │ │ ├── literal.hpp
│ │ │ │ │ │ ├── lru_cache.hpp
│ │ │ │ │ │ ├── meta_kernel.hpp
│ │ │ │ │ │ ├── mpl_vector_to_tuple.hpp
│ │ │ │ │ │ ├── nvidia_compute_capability.hpp
│ │ │ │ │ │ ├── parameter_cache.hpp
│ │ │ │ │ │ ├── path.hpp
│ │ │ │ │ │ ├── print_range.hpp
│ │ │ │ │ │ ├── read_write_single_value.hpp
│ │ │ │ │ │ ├── sha1.hpp
│ │ │ │ │ │ ├── variadic_macros.hpp
│ │ │ │ │ │ ├── vendor.hpp
│ │ │ │ │ │ └── work_size.hpp
│ │ │ │ │ ├── device.hpp
│ │ │ │ │ ├── event.hpp
│ │ │ │ │ ├── exception/
│ │ │ │ │ │ ├── context_error.hpp
│ │ │ │ │ │ ├── no_device_found.hpp
│ │ │ │ │ │ ├── opencl_error.hpp
│ │ │ │ │ │ └── unsupported_extension_error.hpp
│ │ │ │ │ ├── exception.hpp
│ │ │ │ │ ├── experimental/
│ │ │ │ │ │ ├── clamp_range.hpp
│ │ │ │ │ │ ├── malloc.hpp
│ │ │ │ │ │ ├── sort_by_transform.hpp
│ │ │ │ │ │ └── tabulate.hpp
│ │ │ │ │ ├── function.hpp
│ │ │ │ │ ├── functional/
│ │ │ │ │ │ ├── as.hpp
│ │ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── common.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── macros.hpp
│ │ │ │ │ │ │ ├── nvidia_ballot.hpp
│ │ │ │ │ │ │ ├── nvidia_popcount.hpp
│ │ │ │ │ │ │ └── unpack.hpp
│ │ │ │ │ │ ├── field.hpp
│ │ │ │ │ │ ├── geometry.hpp
│ │ │ │ │ │ ├── get.hpp
│ │ │ │ │ │ ├── hash.hpp
│ │ │ │ │ │ ├── identity.hpp
│ │ │ │ │ │ ├── integer.hpp
│ │ │ │ │ │ ├── logical.hpp
│ │ │ │ │ │ ├── math.hpp
│ │ │ │ │ │ ├── operator.hpp
│ │ │ │ │ │ ├── popcount.hpp
│ │ │ │ │ │ └── relational.hpp
│ │ │ │ │ ├── functional.hpp
│ │ │ │ │ ├── image/
│ │ │ │ │ │ ├── image1d.hpp
│ │ │ │ │ │ ├── image2d.hpp
│ │ │ │ │ │ ├── image3d.hpp
│ │ │ │ │ │ ├── image_format.hpp
│ │ │ │ │ │ ├── image_object.hpp
│ │ │ │ │ │ └── image_sampler.hpp
│ │ │ │ │ ├── image.hpp
│ │ │ │ │ ├── image2d.hpp
│ │ │ │ │ ├── image3d.hpp
│ │ │ │ │ ├── image_format.hpp
│ │ │ │ │ ├── image_sampler.hpp
│ │ │ │ │ ├── interop/
│ │ │ │ │ │ ├── eigen/
│ │ │ │ │ │ │ └── core.hpp
│ │ │ │ │ │ ├── eigen.hpp
│ │ │ │ │ │ ├── opencv/
│ │ │ │ │ │ │ ├── core.hpp
│ │ │ │ │ │ │ ├── highgui.hpp
│ │ │ │ │ │ │ └── ocl.hpp
│ │ │ │ │ │ ├── opencv.hpp
│ │ │ │ │ │ ├── opengl/
│ │ │ │ │ │ │ ├── acquire.hpp
│ │ │ │ │ │ │ ├── cl_gl.hpp
│ │ │ │ │ │ │ ├── cl_gl_ext.hpp
│ │ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ │ ├── gl.hpp
│ │ │ │ │ │ │ ├── opengl_buffer.hpp
│ │ │ │ │ │ │ ├── opengl_renderbuffer.hpp
│ │ │ │ │ │ │ └── opengl_texture.hpp
│ │ │ │ │ │ ├── opengl.hpp
│ │ │ │ │ │ ├── qt/
│ │ │ │ │ │ │ ├── qimage.hpp
│ │ │ │ │ │ │ ├── qpoint.hpp
│ │ │ │ │ │ │ ├── qpointf.hpp
│ │ │ │ │ │ │ ├── qtcore.hpp
│ │ │ │ │ │ │ ├── qtgui.hpp
│ │ │ │ │ │ │ └── qvector.hpp
│ │ │ │ │ │ ├── qt.hpp
│ │ │ │ │ │ ├── vtk/
│ │ │ │ │ │ │ ├── bounds.hpp
│ │ │ │ │ │ │ ├── data_array.hpp
│ │ │ │ │ │ │ ├── matrix4x4.hpp
│ │ │ │ │ │ │ └── points.hpp
│ │ │ │ │ │ └── vtk.hpp
│ │ │ │ │ ├── iterator/
│ │ │ │ │ │ ├── buffer_iterator.hpp
│ │ │ │ │ │ ├── constant_buffer_iterator.hpp
│ │ │ │ │ │ ├── constant_iterator.hpp
│ │ │ │ │ │ ├── counting_iterator.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── get_base_iterator_buffer.hpp
│ │ │ │ │ │ │ └── swizzle_iterator.hpp
│ │ │ │ │ │ ├── discard_iterator.hpp
│ │ │ │ │ │ ├── function_input_iterator.hpp
│ │ │ │ │ │ ├── permutation_iterator.hpp
│ │ │ │ │ │ ├── strided_iterator.hpp
│ │ │ │ │ │ ├── transform_iterator.hpp
│ │ │ │ │ │ └── zip_iterator.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── kernel.hpp
│ │ │ │ │ ├── lambda/
│ │ │ │ │ │ ├── context.hpp
│ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ ├── get.hpp
│ │ │ │ │ │ ├── make_pair.hpp
│ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ ├── placeholder.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ └── result_of.hpp
│ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ ├── memory/
│ │ │ │ │ │ ├── local_buffer.hpp
│ │ │ │ │ │ └── svm_ptr.hpp
│ │ │ │ │ ├── memory.hpp
│ │ │ │ │ ├── memory_object.hpp
│ │ │ │ │ ├── pipe.hpp
│ │ │ │ │ ├── platform.hpp
│ │ │ │ │ ├── program.hpp
│ │ │ │ │ ├── random/
│ │ │ │ │ │ ├── bernoulli_distribution.hpp
│ │ │ │ │ │ ├── default_random_engine.hpp
│ │ │ │ │ │ ├── discrete_distribution.hpp
│ │ │ │ │ │ ├── linear_congruential_engine.hpp
│ │ │ │ │ │ ├── mersenne_twister_engine.hpp
│ │ │ │ │ │ ├── normal_distribution.hpp
│ │ │ │ │ │ ├── threefry_engine.hpp
│ │ │ │ │ │ ├── uniform_int_distribution.hpp
│ │ │ │ │ │ └── uniform_real_distribution.hpp
│ │ │ │ │ ├── random.hpp
│ │ │ │ │ ├── source.hpp
│ │ │ │ │ ├── svm.hpp
│ │ │ │ │ ├── system.hpp
│ │ │ │ │ ├── type_traits/
│ │ │ │ │ │ ├── common_type.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── capture_traits.hpp
│ │ │ │ │ │ ├── is_device_iterator.hpp
│ │ │ │ │ │ ├── is_fundamental.hpp
│ │ │ │ │ │ ├── is_vector_type.hpp
│ │ │ │ │ │ ├── make_vector_type.hpp
│ │ │ │ │ │ ├── result_of.hpp
│ │ │ │ │ │ ├── scalar_type.hpp
│ │ │ │ │ │ ├── type_definition.hpp
│ │ │ │ │ │ ├── type_name.hpp
│ │ │ │ │ │ └── vector_size.hpp
│ │ │ │ │ ├── type_traits.hpp
│ │ │ │ │ ├── types/
│ │ │ │ │ │ ├── builtin.hpp
│ │ │ │ │ │ ├── complex.hpp
│ │ │ │ │ │ ├── fundamental.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── struct.hpp
│ │ │ │ │ │ └── tuple.hpp
│ │ │ │ │ ├── types.hpp
│ │ │ │ │ ├── user_event.hpp
│ │ │ │ │ ├── utility/
│ │ │ │ │ │ ├── dim.hpp
│ │ │ │ │ │ ├── extents.hpp
│ │ │ │ │ │ ├── invoke.hpp
│ │ │ │ │ │ ├── program_cache.hpp
│ │ │ │ │ │ ├── source.hpp
│ │ │ │ │ │ └── wait_list.hpp
│ │ │ │ │ ├── utility.hpp
│ │ │ │ │ ├── version.hpp
│ │ │ │ │ └── wait_list.hpp
│ │ │ │ ├── compute.hpp
│ │ │ │ ├── concept/
│ │ │ │ │ ├── assert.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── backward_compatibility.hpp
│ │ │ │ │ │ ├── borland.hpp
│ │ │ │ │ │ ├── concept_def.hpp
│ │ │ │ │ │ ├── concept_undef.hpp
│ │ │ │ │ │ ├── general.hpp
│ │ │ │ │ │ ├── has_constraints.hpp
│ │ │ │ │ │ └── msvc.hpp
│ │ │ │ │ ├── requires.hpp
│ │ │ │ │ └── usage.hpp
│ │ │ │ ├── concept_archetype.hpp
│ │ │ │ ├── concept_check/
│ │ │ │ │ ├── borland.hpp
│ │ │ │ │ ├── general.hpp
│ │ │ │ │ ├── has_constraints.hpp
│ │ │ │ │ └── msvc.hpp
│ │ │ │ ├── concept_check.hpp
│ │ │ │ ├── config/
│ │ │ │ │ ├── abi/
│ │ │ │ │ │ ├── borland_prefix.hpp
│ │ │ │ │ │ ├── borland_suffix.hpp
│ │ │ │ │ │ ├── msvc_prefix.hpp
│ │ │ │ │ │ └── msvc_suffix.hpp
│ │ │ │ │ ├── abi_prefix.hpp
│ │ │ │ │ ├── abi_suffix.hpp
│ │ │ │ │ ├── auto_link.hpp
│ │ │ │ │ ├── compiler/
│ │ │ │ │ │ ├── borland.hpp
│ │ │ │ │ │ ├── clang.hpp
│ │ │ │ │ │ ├── codegear.hpp
│ │ │ │ │ │ ├── comeau.hpp
│ │ │ │ │ │ ├── common_edg.hpp
│ │ │ │ │ │ ├── compaq_cxx.hpp
│ │ │ │ │ │ ├── cray.hpp
│ │ │ │ │ │ ├── digitalmars.hpp
│ │ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ │ ├── gcc_xml.hpp
│ │ │ │ │ │ ├── greenhills.hpp
│ │ │ │ │ │ ├── hp_acc.hpp
│ │ │ │ │ │ ├── intel.hpp
│ │ │ │ │ │ ├── kai.hpp
│ │ │ │ │ │ ├── metrowerks.hpp
│ │ │ │ │ │ ├── mpw.hpp
│ │ │ │ │ │ ├── nvcc.hpp
│ │ │ │ │ │ ├── pathscale.hpp
│ │ │ │ │ │ ├── pgi.hpp
│ │ │ │ │ │ ├── sgi_mipspro.hpp
│ │ │ │ │ │ ├── sunpro_cc.hpp
│ │ │ │ │ │ ├── vacpp.hpp
│ │ │ │ │ │ ├── visualc.hpp
│ │ │ │ │ │ └── xlcpp.hpp
│ │ │ │ │ ├── no_tr1/
│ │ │ │ │ │ ├── cmath.hpp
│ │ │ │ │ │ ├── complex.hpp
│ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ └── utility.hpp
│ │ │ │ │ ├── platform/
│ │ │ │ │ │ ├── aix.hpp
│ │ │ │ │ │ ├── amigaos.hpp
│ │ │ │ │ │ ├── beos.hpp
│ │ │ │ │ │ ├── bsd.hpp
│ │ │ │ │ │ ├── cloudabi.hpp
│ │ │ │ │ │ ├── cray.hpp
│ │ │ │ │ │ ├── cygwin.hpp
│ │ │ │ │ │ ├── haiku.hpp
│ │ │ │ │ │ ├── hpux.hpp
│ │ │ │ │ │ ├── irix.hpp
│ │ │ │ │ │ ├── linux.hpp
│ │ │ │ │ │ ├── macos.hpp
│ │ │ │ │ │ ├── qnxnto.hpp
│ │ │ │ │ │ ├── solaris.hpp
│ │ │ │ │ │ ├── symbian.hpp
│ │ │ │ │ │ ├── vms.hpp
│ │ │ │ │ │ ├── vxworks.hpp
│ │ │ │ │ │ └── win32.hpp
│ │ │ │ │ ├── posix_features.hpp
│ │ │ │ │ ├── requires_threads.hpp
│ │ │ │ │ ├── select_compiler_config.hpp
│ │ │ │ │ ├── select_platform_config.hpp
│ │ │ │ │ ├── select_stdlib_config.hpp
│ │ │ │ │ ├── stdlib/
│ │ │ │ │ │ ├── dinkumware.hpp
│ │ │ │ │ │ ├── libcomo.hpp
│ │ │ │ │ │ ├── libcpp.hpp
│ │ │ │ │ │ ├── libstdcpp3.hpp
│ │ │ │ │ │ ├── modena.hpp
│ │ │ │ │ │ ├── msl.hpp
│ │ │ │ │ │ ├── roguewave.hpp
│ │ │ │ │ │ ├── sgi.hpp
│ │ │ │ │ │ ├── stlport.hpp
│ │ │ │ │ │ └── vacpp.hpp
│ │ │ │ │ ├── suffix.hpp
│ │ │ │ │ ├── user.hpp
│ │ │ │ │ └── warning_disable.hpp
│ │ │ │ ├── config.hpp
│ │ │ │ ├── container/
│ │ │ │ │ ├── adaptive_pool.hpp
│ │ │ │ │ ├── allocator.hpp
│ │ │ │ │ ├── allocator_traits.hpp
│ │ │ │ │ ├── container_fwd.hpp
│ │ │ │ │ ├── deque.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── adaptive_node_pool.hpp
│ │ │ │ │ │ ├── adaptive_node_pool_impl.hpp
│ │ │ │ │ │ ├── addressof.hpp
│ │ │ │ │ │ ├── advanced_insert_int.hpp
│ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ ├── algorithms.hpp
│ │ │ │ │ │ ├── alloc_helpers.hpp
│ │ │ │ │ │ ├── alloc_lib.h
│ │ │ │ │ │ ├── alloc_lib_auto_link.hpp
│ │ │ │ │ │ ├── allocation_type.hpp
│ │ │ │ │ │ ├── allocator_version_traits.hpp
│ │ │ │ │ │ ├── auto_link.hpp
│ │ │ │ │ │ ├── block_list.hpp
│ │ │ │ │ │ ├── block_slist.hpp
│ │ │ │ │ │ ├── compare_functors.hpp
│ │ │ │ │ │ ├── config_begin.hpp
│ │ │ │ │ │ ├── config_end.hpp
│ │ │ │ │ │ ├── construct_in_place.hpp
│ │ │ │ │ │ ├── copy_move_algo.hpp
│ │ │ │ │ │ ├── destroyers.hpp
│ │ │ │ │ │ ├── dispatch_uses_allocator.hpp
│ │ │ │ │ │ ├── dlmalloc.hpp
│ │ │ │ │ │ ├── flat_tree.hpp
│ │ │ │ │ │ ├── function_detector.hpp
│ │ │ │ │ │ ├── hash_table.hpp
│ │ │ │ │ │ ├── is_sorted.hpp
│ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ ├── iterator_to_raw_pointer.hpp
│ │ │ │ │ │ ├── iterators.hpp
│ │ │ │ │ │ ├── math_functions.hpp
│ │ │ │ │ │ ├── memory_util.hpp
│ │ │ │ │ │ ├── min_max.hpp
│ │ │ │ │ │ ├── minimal_char_traits_header.hpp
│ │ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ │ ├── multiallocation_chain.hpp
│ │ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ │ ├── next_capacity.hpp
│ │ │ │ │ │ ├── node_alloc_holder.hpp
│ │ │ │ │ │ ├── node_pool.hpp
│ │ │ │ │ │ ├── node_pool_impl.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── placement_new.hpp
│ │ │ │ │ │ ├── pool_common.hpp
│ │ │ │ │ │ ├── pool_common_alloc.hpp
│ │ │ │ │ │ ├── pool_resource.hpp
│ │ │ │ │ │ ├── preprocessor.hpp
│ │ │ │ │ │ ├── singleton.hpp
│ │ │ │ │ │ ├── std_fwd.hpp
│ │ │ │ │ │ ├── to_raw_pointer.hpp
│ │ │ │ │ │ ├── transform_iterator.hpp
│ │ │ │ │ │ ├── tree.hpp
│ │ │ │ │ │ ├── type_traits.hpp
│ │ │ │ │ │ ├── utilities.hpp
│ │ │ │ │ │ ├── value_init.hpp
│ │ │ │ │ │ ├── variadic_templates_tools.hpp
│ │ │ │ │ │ ├── version_type.hpp
│ │ │ │ │ │ └── workaround.hpp
│ │ │ │ │ ├── flat_map.hpp
│ │ │ │ │ ├── flat_set.hpp
│ │ │ │ │ ├── list.hpp
│ │ │ │ │ ├── map.hpp
│ │ │ │ │ ├── new_allocator.hpp
│ │ │ │ │ ├── node_allocator.hpp
│ │ │ │ │ ├── node_handle.hpp
│ │ │ │ │ ├── options.hpp
│ │ │ │ │ ├── pmr/
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── flat_map.hpp
│ │ │ │ │ │ ├── flat_set.hpp
│ │ │ │ │ │ ├── global_resource.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── memory_resource.hpp
│ │ │ │ │ │ ├── monotonic_buffer_resource.hpp
│ │ │ │ │ │ ├── polymorphic_allocator.hpp
│ │ │ │ │ │ ├── pool_options.hpp
│ │ │ │ │ │ ├── resource_adaptor.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── slist.hpp
│ │ │ │ │ │ ├── small_vector.hpp
│ │ │ │ │ │ ├── stable_vector.hpp
│ │ │ │ │ │ ├── string.hpp
│ │ │ │ │ │ ├── synchronized_pool_resource.hpp
│ │ │ │ │ │ ├── unsynchronized_pool_resource.hpp
│ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ ├── scoped_allocator.hpp
│ │ │ │ │ ├── scoped_allocator_fwd.hpp
│ │ │ │ │ ├── set.hpp
│ │ │ │ │ ├── slist.hpp
│ │ │ │ │ ├── small_vector.hpp
│ │ │ │ │ ├── stable_vector.hpp
│ │ │ │ │ ├── static_vector.hpp
│ │ │ │ │ ├── string.hpp
│ │ │ │ │ ├── throw_exception.hpp
│ │ │ │ │ ├── uses_allocator.hpp
│ │ │ │ │ ├── uses_allocator_fwd.hpp
│ │ │ │ │ └── vector.hpp
│ │ │ │ ├── context/
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── disable_overload.hpp
│ │ │ │ │ │ ├── exception.hpp
│ │ │ │ │ │ ├── exchange.hpp
│ │ │ │ │ │ ├── fcontext.hpp
│ │ │ │ │ │ ├── fcontext_arm.hpp
│ │ │ │ │ │ ├── fcontext_arm_mac.hpp
│ │ │ │ │ │ ├── fcontext_arm_win.hpp
│ │ │ │ │ │ ├── fcontext_i386.hpp
│ │ │ │ │ │ ├── fcontext_i386_win.hpp
│ │ │ │ │ │ ├── fcontext_mips.hpp
│ │ │ │ │ │ ├── fcontext_ppc.hpp
│ │ │ │ │ │ ├── fcontext_sparc.hpp
│ │ │ │ │ │ ├── fcontext_x86_64.hpp
│ │ │ │ │ │ ├── fcontext_x86_64_win.hpp
│ │ │ │ │ │ ├── index_sequence.hpp
│ │ │ │ │ │ ├── invoke.hpp
│ │ │ │ │ │ └── tuple.hpp
│ │ │ │ │ ├── execution_context.hpp
│ │ │ │ │ ├── execution_context_v1.hpp
│ │ │ │ │ ├── execution_context_v2.hpp
│ │ │ │ │ ├── execution_context_v2_void.ipp
│ │ │ │ │ ├── fcontext.hpp
│ │ │ │ │ ├── fixedsize_stack.hpp
│ │ │ │ │ ├── flags.hpp
│ │ │ │ │ ├── pooled_fixedsize_stack.hpp
│ │ │ │ │ ├── posix/
│ │ │ │ │ │ ├── protected_fixedsize_stack.hpp
│ │ │ │ │ │ └── segmented_stack.hpp
│ │ │ │ │ ├── preallocated.hpp
│ │ │ │ │ ├── protected_fixedsize_stack.hpp
│ │ │ │ │ ├── segmented_stack.hpp
│ │ │ │ │ ├── stack_context.hpp
│ │ │ │ │ ├── stack_traits.hpp
│ │ │ │ │ └── windows/
│ │ │ │ │ └── protected_fixedsize_stack.hpp
│ │ │ │ ├── convert/
│ │ │ │ │ ├── base.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── boost_parameter_ext.hpp
│ │ │ │ │ │ ├── char.hpp
│ │ │ │ │ │ ├── forward.hpp
│ │ │ │ │ │ ├── has_member.hpp
│ │ │ │ │ │ ├── is_callable.hpp
│ │ │ │ │ │ ├── is_converter.hpp
│ │ │ │ │ │ ├── is_fun.hpp
│ │ │ │ │ │ ├── is_string.hpp
│ │ │ │ │ │ └── range.hpp
│ │ │ │ │ ├── lexical_cast.hpp
│ │ │ │ │ ├── parameters.hpp
│ │ │ │ │ ├── printf.hpp
│ │ │ │ │ ├── spirit.hpp
│ │ │ │ │ ├── stream.hpp
│ │ │ │ │ └── strtol.hpp
│ │ │ │ ├── convert.hpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── addressof.hpp
│ │ │ │ │ ├── checked_delete.hpp
│ │ │ │ │ ├── demangle.hpp
│ │ │ │ │ ├── enable_if.hpp
│ │ │ │ │ ├── explicit_operator_bool.hpp
│ │ │ │ │ ├── ignore_unused.hpp
│ │ │ │ │ ├── is_same.hpp
│ │ │ │ │ ├── lightweight_test.hpp
│ │ │ │ │ ├── lightweight_test_trait.hpp
│ │ │ │ │ ├── no_exceptions_support.hpp
│ │ │ │ │ ├── noncopyable.hpp
│ │ │ │ │ ├── null_deleter.hpp
│ │ │ │ │ ├── ref.hpp
│ │ │ │ │ ├── scoped_enum.hpp
│ │ │ │ │ ├── swap.hpp
│ │ │ │ │ ├── typeinfo.hpp
│ │ │ │ │ └── underlying_type.hpp
│ │ │ │ ├── coroutine/
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── asymmetric_coroutine.hpp
│ │ │ │ │ ├── attributes.hpp
│ │ │ │ │ ├── coroutine.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── coroutine_context.hpp
│ │ │ │ │ │ ├── data.hpp
│ │ │ │ │ │ ├── flags.hpp
│ │ │ │ │ │ ├── parameters.hpp
│ │ │ │ │ │ ├── preallocated.hpp
│ │ │ │ │ │ ├── pull_coroutine_impl.hpp
│ │ │ │ │ │ ├── pull_coroutine_object.hpp
│ │ │ │ │ │ ├── pull_coroutine_synthesized.hpp
│ │ │ │ │ │ ├── push_coroutine_impl.hpp
│ │ │ │ │ │ ├── push_coroutine_object.hpp
│ │ │ │ │ │ ├── push_coroutine_synthesized.hpp
│ │ │ │ │ │ ├── setup.hpp
│ │ │ │ │ │ ├── symmetric_coroutine_call.hpp
│ │ │ │ │ │ ├── symmetric_coroutine_impl.hpp
│ │ │ │ │ │ ├── symmetric_coroutine_object.hpp
│ │ │ │ │ │ ├── symmetric_coroutine_yield.hpp
│ │ │ │ │ │ ├── trampoline.hpp
│ │ │ │ │ │ ├── trampoline_pull.hpp
│ │ │ │ │ │ └── trampoline_push.hpp
│ │ │ │ │ ├── exceptions.hpp
│ │ │ │ │ ├── flags.hpp
│ │ │ │ │ ├── posix/
│ │ │ │ │ │ ├── protected_stack_allocator.hpp
│ │ │ │ │ │ └── segmented_stack_allocator.hpp
│ │ │ │ │ ├── protected_stack_allocator.hpp
│ │ │ │ │ ├── segmented_stack_allocator.hpp
│ │ │ │ │ ├── stack_allocator.hpp
│ │ │ │ │ ├── stack_context.hpp
│ │ │ │ │ ├── stack_traits.hpp
│ │ │ │ │ ├── standard_stack_allocator.hpp
│ │ │ │ │ ├── symmetric_coroutine.hpp
│ │ │ │ │ └── windows/
│ │ │ │ │ └── protected_stack_allocator.hpp
│ │ │ │ ├── coroutine2/
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── coroutine.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── coroutine.hpp
│ │ │ │ │ │ ├── create_control_block.ipp
│ │ │ │ │ │ ├── decay_copy.hpp
│ │ │ │ │ │ ├── disable_overload.hpp
│ │ │ │ │ │ ├── forced_unwind.hpp
│ │ │ │ │ │ ├── pull_control_block_ecv1.hpp
│ │ │ │ │ │ ├── pull_control_block_ecv1.ipp
│ │ │ │ │ │ ├── pull_control_block_ecv2.hpp
│ │ │ │ │ │ ├── pull_control_block_ecv2.ipp
│ │ │ │ │ │ ├── pull_coroutine.hpp
│ │ │ │ │ │ ├── pull_coroutine.ipp
│ │ │ │ │ │ ├── push_control_block_ecv1.hpp
│ │ │ │ │ │ ├── push_control_block_ecv1.ipp
│ │ │ │ │ │ ├── push_control_block_ecv2.hpp
│ │ │ │ │ │ ├── push_control_block_ecv2.ipp
│ │ │ │ │ │ ├── push_coroutine.hpp
│ │ │ │ │ │ ├── push_coroutine.ipp
│ │ │ │ │ │ └── state.hpp
│ │ │ │ │ ├── fixedsize_stack.hpp
│ │ │ │ │ ├── pooled_fixedsize_stack.hpp
│ │ │ │ │ ├── protected_fixedsize_stack.hpp
│ │ │ │ │ └── segmented_stack.hpp
│ │ │ │ ├── crc.hpp
│ │ │ │ ├── cregex.hpp
│ │ │ │ ├── cstdfloat.hpp
│ │ │ │ ├── cstdint.hpp
│ │ │ │ ├── cstdlib.hpp
│ │ │ │ ├── current_function.hpp
│ │ │ │ ├── cxx11_char_types.hpp
│ │ │ │ ├── date_time/
│ │ │ │ │ ├── adjust_functors.hpp
│ │ │ │ │ ├── c_local_time_adjustor.hpp
│ │ │ │ │ ├── c_time.hpp
│ │ │ │ │ ├── compiler_config.hpp
│ │ │ │ │ ├── constrained_value.hpp
│ │ │ │ │ ├── date.hpp
│ │ │ │ │ ├── date_clock_device.hpp
│ │ │ │ │ ├── date_defs.hpp
│ │ │ │ │ ├── date_duration.hpp
│ │ │ │ │ ├── date_duration_types.hpp
│ │ │ │ │ ├── date_facet.hpp
│ │ │ │ │ ├── date_format_simple.hpp
│ │ │ │ │ ├── date_formatting.hpp
│ │ │ │ │ ├── date_formatting_limited.hpp
│ │ │ │ │ ├── date_formatting_locales.hpp
│ │ │ │ │ ├── date_generator_formatter.hpp
│ │ │ │ │ ├── date_generator_parser.hpp
│ │ │ │ │ ├── date_generators.hpp
│ │ │ │ │ ├── date_iterator.hpp
│ │ │ │ │ ├── date_names_put.hpp
│ │ │ │ │ ├── date_parsing.hpp
│ │ │ │ │ ├── dst_rules.hpp
│ │ │ │ │ ├── dst_transition_generators.hpp
│ │ │ │ │ ├── filetime_functions.hpp
│ │ │ │ │ ├── format_date_parser.hpp
│ │ │ │ │ ├── gregorian/
│ │ │ │ │ │ ├── conversion.hpp
│ │ │ │ │ │ ├── formatters.hpp
│ │ │ │ │ │ ├── formatters_limited.hpp
│ │ │ │ │ │ ├── greg_calendar.hpp
│ │ │ │ │ │ ├── greg_date.hpp
│ │ │ │ │ │ ├── greg_day.hpp
│ │ │ │ │ │ ├── greg_day_of_year.hpp
│ │ │ │ │ │ ├── greg_duration.hpp
│ │ │ │ │ │ ├── greg_duration_types.hpp
│ │ │ │ │ │ ├── greg_facet.hpp
│ │ │ │ │ │ ├── greg_month.hpp
│ │ │ │ │ │ ├── greg_serialize.hpp
│ │ │ │ │ │ ├── greg_weekday.hpp
│ │ │ │ │ │ ├── greg_year.hpp
│ │ │ │ │ │ ├── greg_ymd.hpp
│ │ │ │ │ │ ├── gregorian.hpp
│ │ │ │ │ │ ├── gregorian_io.hpp
│ │ │ │ │ │ ├── gregorian_types.hpp
│ │ │ │ │ │ └── parsers.hpp
│ │ │ │ │ ├── gregorian_calendar.hpp
│ │ │ │ │ ├── gregorian_calendar.ipp
│ │ │ │ │ ├── int_adapter.hpp
│ │ │ │ │ ├── iso_format.hpp
│ │ │ │ │ ├── local_time/
│ │ │ │ │ │ ├── conversion.hpp
│ │ │ │ │ │ ├── custom_time_zone.hpp
│ │ │ │ │ │ ├── date_duration_operators.hpp
│ │ │ │ │ │ ├── dst_transition_day_rules.hpp
│ │ │ │ │ │ ├── local_date_time.hpp
│ │ │ │ │ │ ├── local_time.hpp
│ │ │ │ │ │ ├── local_time_io.hpp
│ │ │ │ │ │ ├── local_time_types.hpp
│ │ │ │ │ │ ├── posix_time_zone.hpp
│ │ │ │ │ │ └── tz_database.hpp
│ │ │ │ │ ├── local_time_adjustor.hpp
│ │ │ │ │ ├── local_timezone_defs.hpp
│ │ │ │ │ ├── locale_config.hpp
│ │ │ │ │ ├── microsec_time_clock.hpp
│ │ │ │ │ ├── parse_format_base.hpp
│ │ │ │ │ ├── period.hpp
│ │ │ │ │ ├── period_formatter.hpp
│ │ │ │ │ ├── period_parser.hpp
│ │ │ │ │ ├── posix_time/
│ │ │ │ │ │ ├── conversion.hpp
│ │ │ │ │ │ ├── date_duration_operators.hpp
│ │ │ │ │ │ ├── posix_time.hpp
│ │ │ │ │ │ ├── posix_time_config.hpp
│ │ │ │ │ │ ├── posix_time_duration.hpp
│ │ │ │ │ │ ├── posix_time_io.hpp
│ │ │ │ │ │ ├── posix_time_legacy_io.hpp
│ │ │ │ │ │ ├── posix_time_system.hpp
│ │ │ │ │ │ ├── posix_time_types.hpp
│ │ │ │ │ │ ├── ptime.hpp
│ │ │ │ │ │ ├── time_formatters.hpp
│ │ │ │ │ │ ├── time_formatters_limited.hpp
│ │ │ │ │ │ ├── time_parsers.hpp
│ │ │ │ │ │ ├── time_period.hpp
│ │ │ │ │ │ └── time_serialize.hpp
│ │ │ │ │ ├── special_defs.hpp
│ │ │ │ │ ├── special_values_formatter.hpp
│ │ │ │ │ ├── special_values_parser.hpp
│ │ │ │ │ ├── string_convert.hpp
│ │ │ │ │ ├── string_parse_tree.hpp
│ │ │ │ │ ├── strings_from_facet.hpp
│ │ │ │ │ ├── time.hpp
│ │ │ │ │ ├── time_clock.hpp
│ │ │ │ │ ├── time_defs.hpp
│ │ │ │ │ ├── time_duration.hpp
│ │ │ │ │ ├── time_facet.hpp
│ │ │ │ │ ├── time_formatting_streams.hpp
│ │ │ │ │ ├── time_iterator.hpp
│ │ │ │ │ ├── time_parsing.hpp
│ │ │ │ │ ├── time_resolution_traits.hpp
│ │ │ │ │ ├── time_system_counted.hpp
│ │ │ │ │ ├── time_system_split.hpp
│ │ │ │ │ ├── time_zone_base.hpp
│ │ │ │ │ ├── time_zone_names.hpp
│ │ │ │ │ ├── tz_db_base.hpp
│ │ │ │ │ ├── wrapping_int.hpp
│ │ │ │ │ └── year_month_day.hpp
│ │ │ │ ├── date_time.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── allocator_utilities.hpp
│ │ │ │ │ ├── atomic_count.hpp
│ │ │ │ │ ├── atomic_redef_macros.hpp
│ │ │ │ │ ├── atomic_undef_macros.hpp
│ │ │ │ │ ├── basic_pointerbuf.hpp
│ │ │ │ │ ├── binary_search.hpp
│ │ │ │ │ ├── bitmask.hpp
│ │ │ │ │ ├── call_traits.hpp
│ │ │ │ │ ├── catch_exceptions.hpp
│ │ │ │ │ ├── compressed_pair.hpp
│ │ │ │ │ ├── container_fwd.hpp
│ │ │ │ │ ├── dynamic_bitset.hpp
│ │ │ │ │ ├── endian.hpp
│ │ │ │ │ ├── fenv.hpp
│ │ │ │ │ ├── has_default_constructor.hpp
│ │ │ │ │ ├── identifier.hpp
│ │ │ │ │ ├── indirect_traits.hpp
│ │ │ │ │ ├── interlocked.hpp
│ │ │ │ │ ├── is_incrementable.hpp
│ │ │ │ │ ├── is_sorted.hpp
│ │ │ │ │ ├── is_xxx.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── lcast_precision.hpp
│ │ │ │ │ ├── lightweight_main.hpp
│ │ │ │ │ ├── lightweight_mutex.hpp
│ │ │ │ │ ├── lightweight_test.hpp
│ │ │ │ │ ├── lightweight_test_report.hpp
│ │ │ │ │ ├── lightweight_thread.hpp
│ │ │ │ │ ├── named_template_params.hpp
│ │ │ │ │ ├── no_exceptions_support.hpp
│ │ │ │ │ ├── numeric_traits.hpp
│ │ │ │ │ ├── ob_compressed_pair.hpp
│ │ │ │ │ ├── quick_allocator.hpp
│ │ │ │ │ ├── reference_content.hpp
│ │ │ │ │ ├── scoped_enum_emulation.hpp
│ │ │ │ │ ├── select_type.hpp
│ │ │ │ │ ├── sp_typeinfo.hpp
│ │ │ │ │ ├── templated_streams.hpp
│ │ │ │ │ ├── utf8_codecvt_facet.hpp
│ │ │ │ │ ├── utf8_codecvt_facet.ipp
│ │ │ │ │ ├── winapi/
│ │ │ │ │ │ ├── GetCurrentProcess.hpp
│ │ │ │ │ │ ├── GetCurrentThread.hpp
│ │ │ │ │ │ ├── GetLastError.hpp
│ │ │ │ │ │ ├── GetProcessTimes.hpp
│ │ │ │ │ │ ├── GetThreadTimes.hpp
│ │ │ │ │ │ ├── LocalFree.hpp
│ │ │ │ │ │ ├── access_rights.hpp
│ │ │ │ │ │ ├── apc.hpp
│ │ │ │ │ │ ├── basic_types.hpp
│ │ │ │ │ │ ├── character_code_conversion.hpp
│ │ │ │ │ │ ├── condition_variable.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── critical_section.hpp
│ │ │ │ │ │ ├── crypt.hpp
│ │ │ │ │ │ ├── dbghelp.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── cast_ptr.hpp
│ │ │ │ │ │ ├── directory_management.hpp
│ │ │ │ │ │ ├── dll.hpp
│ │ │ │ │ │ ├── environment.hpp
│ │ │ │ │ │ ├── error_codes.hpp
│ │ │ │ │ │ ├── error_handling.hpp
│ │ │ │ │ │ ├── event.hpp
│ │ │ │ │ │ ├── file_management.hpp
│ │ │ │ │ │ ├── file_mapping.hpp
│ │ │ │ │ │ ├── get_current_process.hpp
│ │ │ │ │ │ ├── get_current_process_id.hpp
│ │ │ │ │ │ ├── get_current_thread.hpp
│ │ │ │ │ │ ├── get_current_thread_id.hpp
│ │ │ │ │ │ ├── get_last_error.hpp
│ │ │ │ │ │ ├── get_process_times.hpp
│ │ │ │ │ │ ├── get_system_directory.hpp
│ │ │ │ │ │ ├── get_thread_times.hpp
│ │ │ │ │ │ ├── handle_info.hpp
│ │ │ │ │ │ ├── handles.hpp
│ │ │ │ │ │ ├── heap_memory.hpp
│ │ │ │ │ │ ├── init_once.hpp
│ │ │ │ │ │ ├── jobs.hpp
│ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ ├── local_memory.hpp
│ │ │ │ │ │ ├── memory.hpp
│ │ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ │ ├── overlapped.hpp
│ │ │ │ │ │ ├── page_protection_flags.hpp
│ │ │ │ │ │ ├── pipes.hpp
│ │ │ │ │ │ ├── priority_class.hpp
│ │ │ │ │ │ ├── process.hpp
│ │ │ │ │ │ ├── security.hpp
│ │ │ │ │ │ ├── semaphore.hpp
│ │ │ │ │ │ ├── shell.hpp
│ │ │ │ │ │ ├── show_window.hpp
│ │ │ │ │ │ ├── srw_lock.hpp
│ │ │ │ │ │ ├── synchronization.hpp
│ │ │ │ │ │ ├── system.hpp
│ │ │ │ │ │ ├── thread.hpp
│ │ │ │ │ │ ├── thread_pool.hpp
│ │ │ │ │ │ ├── time.hpp
│ │ │ │ │ │ ├── timers.hpp
│ │ │ │ │ │ ├── tls.hpp
│ │ │ │ │ │ ├── wait.hpp
│ │ │ │ │ │ └── waitable_timer.hpp
│ │ │ │ │ └── workaround.hpp
│ │ │ │ ├── dll/
│ │ │ │ │ ├── alias.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── aggressive_ptr_cast.hpp
│ │ │ │ │ │ ├── ctor_dtor.hpp
│ │ │ │ │ │ ├── demangling/
│ │ │ │ │ │ │ ├── demangle_symbol.hpp
│ │ │ │ │ │ │ ├── itanium.hpp
│ │ │ │ │ │ │ ├── mangled_storage_base.hpp
│ │ │ │ │ │ │ └── msvc.hpp
│ │ │ │ │ │ ├── elf_info.hpp
│ │ │ │ │ │ ├── get_mem_fn_type.hpp
│ │ │ │ │ │ ├── import_mangled_helpers.hpp
│ │ │ │ │ │ ├── macho_info.hpp
│ │ │ │ │ │ ├── pe_info.hpp
│ │ │ │ │ │ ├── posix/
│ │ │ │ │ │ │ ├── path_from_handle.hpp
│ │ │ │ │ │ │ ├── program_location_impl.hpp
│ │ │ │ │ │ │ └── shared_library_impl.hpp
│ │ │ │ │ │ ├── system_error.hpp
│ │ │ │ │ │ ├── type_info.hpp
│ │ │ │ │ │ ├── windows/
│ │ │ │ │ │ │ ├── path_from_handle.hpp
│ │ │ │ │ │ │ └── shared_library_impl.hpp
│ │ │ │ │ │ └── x_info_interface.hpp
│ │ │ │ │ ├── import.hpp
│ │ │ │ │ ├── import_class.hpp
│ │ │ │ │ ├── import_mangled.hpp
│ │ │ │ │ ├── library_info.hpp
│ │ │ │ │ ├── runtime_symbol_info.hpp
│ │ │ │ │ ├── shared_library.hpp
│ │ │ │ │ ├── shared_library_load_mode.hpp
│ │ │ │ │ └── smart_library.hpp
│ │ │ │ ├── dll.hpp
│ │ │ │ ├── dynamic_bitset/
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ └── dynamic_bitset.hpp
│ │ │ │ ├── dynamic_bitset.hpp
│ │ │ │ ├── dynamic_bitset_fwd.hpp
│ │ │ │ ├── enable_shared_from_this.hpp
│ │ │ │ ├── endian/
│ │ │ │ │ ├── arithmetic.hpp
│ │ │ │ │ ├── buffers.hpp
│ │ │ │ │ ├── conversion.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── cover_operators.hpp
│ │ │ │ │ │ ├── disable_warnings.hpp
│ │ │ │ │ │ ├── disable_warnings_pop.hpp
│ │ │ │ │ │ ├── intrinsic.hpp
│ │ │ │ │ │ └── lightweight_test.hpp
│ │ │ │ │ ├── endian.hpp
│ │ │ │ │ └── std_pair.hpp
│ │ │ │ ├── exception/
│ │ │ │ │ ├── N3757.hpp
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── current_exception_cast.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── clone_current_exception.hpp
│ │ │ │ │ │ ├── error_info_impl.hpp
│ │ │ │ │ │ ├── exception_ptr.hpp
│ │ │ │ │ │ ├── is_output_streamable.hpp
│ │ │ │ │ │ ├── object_hex_dump.hpp
│ │ │ │ │ │ ├── shared_ptr.hpp
│ │ │ │ │ │ └── type_info.hpp
│ │ │ │ │ ├── diagnostic_information.hpp
│ │ │ │ │ ├── enable_current_exception.hpp
│ │ │ │ │ ├── enable_error_info.hpp
│ │ │ │ │ ├── errinfo_api_function.hpp
│ │ │ │ │ ├── errinfo_at_line.hpp
│ │ │ │ │ ├── errinfo_errno.hpp
│ │ │ │ │ ├── errinfo_file_handle.hpp
│ │ │ │ │ ├── errinfo_file_name.hpp
│ │ │ │ │ ├── errinfo_file_open_mode.hpp
│ │ │ │ │ ├── errinfo_nested_exception.hpp
│ │ │ │ │ ├── errinfo_type_info_name.hpp
│ │ │ │ │ ├── error_info.hpp
│ │ │ │ │ ├── exception.hpp
│ │ │ │ │ ├── get_error_info.hpp
│ │ │ │ │ ├── info.hpp
│ │ │ │ │ ├── info_tuple.hpp
│ │ │ │ │ ├── to_string.hpp
│ │ │ │ │ └── to_string_stub.hpp
│ │ │ │ ├── exception_ptr.hpp
│ │ │ │ ├── fiber/
│ │ │ │ │ ├── algo/
│ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── chase_lev_queue.hpp
│ │ │ │ │ │ ├── round_robin.hpp
│ │ │ │ │ │ ├── shared_work.hpp
│ │ │ │ │ │ └── work_stealing.hpp
│ │ │ │ │ ├── all.hpp
│ │ │ │ │ ├── barrier.hpp
│ │ │ │ │ ├── bounded_channel.hpp
│ │ │ │ │ ├── buffered_channel.hpp
│ │ │ │ │ ├── channel_op_status.hpp
│ │ │ │ │ ├── condition_variable.hpp
│ │ │ │ │ ├── context.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── context_mpsc_queue.hpp
│ │ │ │ │ │ ├── context_spmc_queue.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── cpu_relax.hpp
│ │ │ │ │ │ ├── data.hpp
│ │ │ │ │ │ ├── decay_copy.hpp
│ │ │ │ │ │ ├── disable_overload.hpp
│ │ │ │ │ │ ├── fss.hpp
│ │ │ │ │ │ ├── futex.hpp
│ │ │ │ │ │ ├── spinlock.hpp
│ │ │ │ │ │ ├── spinlock_ttas.hpp
│ │ │ │ │ │ ├── spinlock_ttas_adaptive.hpp
│ │ │ │ │ │ ├── spinlock_ttas_adaptive_futex.hpp
│ │ │ │ │ │ ├── spinlock_ttas_futex.hpp
│ │ │ │ │ │ └── wrap.hpp
│ │ │ │ │ ├── exceptions.hpp
│ │ │ │ │ ├── fiber.hpp
│ │ │ │ │ ├── fixedsize_stack.hpp
│ │ │ │ │ ├── fss.hpp
│ │ │ │ │ ├── future/
│ │ │ │ │ │ ├── async.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── shared_state.hpp
│ │ │ │ │ │ │ ├── shared_state_object.hpp
│ │ │ │ │ │ │ ├── task_base.hpp
│ │ │ │ │ │ │ └── task_object.hpp
│ │ │ │ │ │ ├── future.hpp
│ │ │ │ │ │ ├── future_status.hpp
│ │ │ │ │ │ ├── packaged_task.hpp
│ │ │ │ │ │ └── promise.hpp
│ │ │ │ │ ├── future.hpp
│ │ │ │ │ ├── mutex.hpp
│ │ │ │ │ ├── operations.hpp
│ │ │ │ │ ├── policy.hpp
│ │ │ │ │ ├── pooled_fixedsize_stack.hpp
│ │ │ │ │ ├── properties.hpp
│ │ │ │ │ ├── protected_fixedsize_stack.hpp
│ │ │ │ │ ├── recursive_mutex.hpp
│ │ │ │ │ ├── recursive_timed_mutex.hpp
│ │ │ │ │ ├── scheduler.hpp
│ │ │ │ │ ├── segmented_stack.hpp
│ │ │ │ │ ├── timed_mutex.hpp
│ │ │ │ │ ├── type.hpp
│ │ │ │ │ ├── unbounded_channel.hpp
│ │ │ │ │ └── unbuffered_channel.hpp
│ │ │ │ ├── filesystem/
│ │ │ │ │ ├── config.hpp
│ │ │ │ │ ├── convenience.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ └── utf8_codecvt_facet.hpp
│ │ │ │ │ ├── exception.hpp
│ │ │ │ │ ├── fstream.hpp
│ │ │ │ │ ├── operations.hpp
│ │ │ │ │ ├── path.hpp
│ │ │ │ │ ├── path_traits.hpp
│ │ │ │ │ └── string_file.hpp
│ │ │ │ ├── filesystem.hpp
│ │ │ │ ├── flyweight/
│ │ │ │ │ ├── assoc_container_factory.hpp
│ │ │ │ │ ├── assoc_container_factory_fwd.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── archive_constructed.hpp
│ │ │ │ │ │ ├── default_value_policy.hpp
│ │ │ │ │ │ ├── dyn_perfect_fwd.hpp
│ │ │ │ │ │ ├── flyweight_core.hpp
│ │ │ │ │ │ ├── is_placeholder_expr.hpp
│ │ │ │ │ │ ├── nested_xxx_if_not_ph.hpp
│ │ │ │ │ │ ├── not_placeholder_expr.hpp
│ │ │ │ │ │ ├── perfect_fwd.hpp
│ │ │ │ │ │ ├── pp_perfect_fwd.hpp
│ │ │ │ │ │ ├── recursive_lw_mutex.hpp
│ │ │ │ │ │ ├── serialization_helper.hpp
│ │ │ │ │ │ └── value_tag.hpp
│ │ │ │ │ ├── factory_tag.hpp
│ │ │ │ │ ├── flyweight.hpp
│ │ │ │ │ ├── flyweight_fwd.hpp
│ │ │ │ │ ├── hashed_factory.hpp
│ │ │ │ │ ├── hashed_factory_fwd.hpp
│ │ │ │ │ ├── holder_tag.hpp
│ │ │ │ │ ├── intermodule_holder.hpp
│ │ │ │ │ ├── intermodule_holder_fwd.hpp
│ │ │ │ │ ├── key_value.hpp
│ │ │ │ │ ├── key_value_fwd.hpp
│ │ │ │ │ ├── locking_tag.hpp
│ │ │ │ │ ├── no_locking.hpp
│ │ │ │ │ ├── no_locking_fwd.hpp
│ │ │ │ │ ├── no_tracking.hpp
│ │ │ │ │ ├── no_tracking_fwd.hpp
│ │ │ │ │ ├── refcounted.hpp
│ │ │ │ │ ├── refcounted_fwd.hpp
│ │ │ │ │ ├── serialize.hpp
│ │ │ │ │ ├── set_factory.hpp
│ │ │ │ │ ├── set_factory_fwd.hpp
│ │ │ │ │ ├── simple_locking.hpp
│ │ │ │ │ ├── simple_locking_fwd.hpp
│ │ │ │ │ ├── static_holder.hpp
│ │ │ │ │ ├── static_holder_fwd.hpp
│ │ │ │ │ ├── tag.hpp
│ │ │ │ │ └── tracking_tag.hpp
│ │ │ │ ├── flyweight.hpp
│ │ │ │ ├── foreach.hpp
│ │ │ │ ├── foreach_fwd.hpp
│ │ │ │ ├── format/
│ │ │ │ │ ├── alt_sstream.hpp
│ │ │ │ │ ├── alt_sstream_impl.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── compat_workarounds.hpp
│ │ │ │ │ │ ├── config_macros.hpp
│ │ │ │ │ │ ├── msvc_disambiguater.hpp
│ │ │ │ │ │ ├── unset_macros.hpp
│ │ │ │ │ │ ├── workarounds_gcc-2_95.hpp
│ │ │ │ │ │ └── workarounds_stlport.hpp
│ │ │ │ │ ├── exceptions.hpp
│ │ │ │ │ ├── feed_args.hpp
│ │ │ │ │ ├── format_class.hpp
│ │ │ │ │ ├── format_fwd.hpp
│ │ │ │ │ ├── format_implementation.hpp
│ │ │ │ │ ├── free_funcs.hpp
│ │ │ │ │ ├── group.hpp
│ │ │ │ │ ├── internals.hpp
│ │ │ │ │ ├── internals_fwd.hpp
│ │ │ │ │ └── parsing.hpp
│ │ │ │ ├── format.hpp
│ │ │ │ ├── function/
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── function_iterate.hpp
│ │ │ │ │ │ ├── gen_maybe_include.pl
│ │ │ │ │ │ ├── maybe_include.hpp
│ │ │ │ │ │ └── prologue.hpp
│ │ │ │ │ ├── function0.hpp
│ │ │ │ │ ├── function1.hpp
│ │ │ │ │ ├── function10.hpp
│ │ │ │ │ ├── function2.hpp
│ │ │ │ │ ├── function3.hpp
│ │ │ │ │ ├── function4.hpp
│ │ │ │ │ ├── function5.hpp
│ │ │ │ │ ├── function6.hpp
│ │ │ │ │ ├── function7.hpp
│ │ │ │ │ ├── function8.hpp
│ │ │ │ │ ├── function9.hpp
│ │ │ │ │ ├── function_base.hpp
│ │ │ │ │ ├── function_fwd.hpp
│ │ │ │ │ ├── function_template.hpp
│ │ │ │ │ ├── function_typeof.hpp
│ │ │ │ │ └── gen_function_N.pl
│ │ │ │ ├── function.hpp
│ │ │ │ ├── function_equal.hpp
│ │ │ │ ├── function_output_iterator.hpp
│ │ │ │ ├── function_types/
│ │ │ │ │ ├── components.hpp
│ │ │ │ │ ├── config/
│ │ │ │ │ │ ├── cc_names.hpp
│ │ │ │ │ │ ├── compiler.hpp
│ │ │ │ │ │ └── config.hpp
│ │ │ │ │ ├── detail/
│ │ │ │ │ │ ├── class_transform.hpp
│ │ │ │ │ │ ├── classifier.hpp
│ │ │ │ │ │ ├── classifier_impl/
│ │ │ │ │ │ │ ├── arity10_0.hpp
│ │ │ │ │ │ │ ├── arity10_1.hpp
│ │ │ │ │ │ │ ├── arity20_0.hpp
│ │ │ │ │ │ │ ├── arity20_1.hpp
│ │ │ │ │ │ │ ├── arity30_0.hpp
│ │ │ │ │ │ │ ├── arity30_1.hpp
│ │ │ │ │ │ │ ├── arity40_0.hpp
│ │ │ │ │ │ │ ├── arity40_1.hpp
│ │ │ │ │ │ │ ├── arity50_0.hpp
│ │ │ │ │ │ │ ├── arity50_1.hpp
│ │ │ │ │ │ │ └── master.hpp
│ │ │ │ │ │ ├── components_as_mpl_sequence.hpp
│ │ │ │ │ │ ├── components_impl/
│ │ │ │ │ │ │ ├── arity10_0.hpp
│ │ │ │ │ │ │ ├── arity10_1.hpp
│ │ │ │ │ │ │ ├── arity20_0.hpp
│ │ │ │ │ │ │ ├── arity20_1.hpp
│ │ │ │ │ │ │ ├── arity30_0.hpp
│ │ │ │ │ │ │ ├── arity30_1.hpp
│ │ │ │ │ │ │ ├── arity40_0.hpp
│ │ │ │ │ │ │ ├── arity40_1.hpp
│ │ │ │ │ │ │ ├── arity50_0.hpp
│ │ │ │ │ │ │ ├── arity50_1.hpp
│ │ │ │ │ │ │ └── master.hpp
│ │ │ │ │ │ ├── cv_traits.hpp
│ │ │ │ │ │ ├── encoding/
│ │ │ │ │ │ │ ├── aliases_def.hpp
│ │ │ │ │ │ │ ├── aliases_undef.hpp
│ │ │ │ │ │ │ ├── def.hpp
│ │ │ │ │ │ │ └── undef.hpp
│ │ │ │ │ │ ├── pp_arity_loop.hpp
│ │ │ │ │ │ ├── pp_cc_loop/
│ │ │ │ │ │ │ ├── master.hpp
│ │ │ │ │ │ │ └── preprocessed.hpp
│ │ │ │ │ │ ├── pp_loop.hpp
│ │ │ │ │ │ ├── pp_retag_default_cc/
│ │ │ │ │ │ │ ├── master.hpp
│ │ │ │ │ │ │ └── preprocessed.hpp
│ │ │ │ │ │ ├── pp_tags/
│ │ │ │ │ │ │ ├── cc_tag.hpp
│ │ │ │ │ │ │ ├── master.hpp
│ │ │ │ │ │ │ └── preprocessed.hpp
│ │ │ │ │ │ ├── pp_variate_loop/
│ │ │ │ │ │ │ ├── master.hpp
│ │ │ │ │ │ │ └── preprocessed.hpp
│ │ │ │ │ │ ├── retag_default_cc.hpp
│ │ │ │ │ │ ├── synthesize.hpp
│ │ │ │ │ │ ├── synthesize_impl/
│ │ │ │ │ │ │ ├── arity10_0.hpp
│ │ │ │ │ │ │ ├── arity10_1.hpp
│ │ │ │ │ │ │ ├── arity20_0.hpp
│ │ │ │ │ │ │ ├── arity20_1.hpp
│ │ │ │ │ │ │ ├── arity30_0.hpp
│ │ │ │ │ │ │ ├── arity30_1.hpp
│ │ │ │ │ │ │ ├── arity40_0.hpp
│ │ │ │ │ │ │ ├── arity40_1.hpp
│ │ │ │ │ │ │ ├── arity50_0.hpp
│ │ │ │ │ │ │ ├── arity50_1.hpp
│ │ │ │ │ │ │ └── master.hpp
│ │ │ │ │ │ └── to_sequence.hpp
│ │ │ │ │ ├── function_arity.hpp
│ │ │ │ │ ├── function_pointer.hpp
│ │ │ │ │ ├── function_reference.hpp
│ │ │ │ │ ├── function_type.hpp
│ │ │ │ │ ├── is_callable_builtin.hpp
│ │ │ │ │ ├── is_function.hpp
│ │ │ │ │ ├── is_function_pointer.hpp
│ │ │ │ │ ├── is_function_reference.hpp
│ │ │ │ │ ├── is_member_function_pointer.hpp
│ │ │ │ │ ├── is_member_object_pointer.hpp
│ │ │ │ │ ├── is_member_pointer.hpp
│ │ │ │ │ ├── is_nonmember_callable_builtin.hpp
│ │ │ │ │ ├── member_function_pointer.hpp
│ │ │ │ │ ├── member_object_pointer.hpp
│ │ │ │ │ ├── parameter_types.hpp
│ │ │ │ │ ├── property_tags.hpp
│ │ │ │ │ └── result_type.hpp
│ │ │ │ ├── functional/
│ │ │ │ │ ├── factory.hpp
│ │ │ │ │ ├── forward_adapter.hpp
│ │ │ │ │ ├── hash/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── float_functions.hpp
│ │ │ │ │ │ │ ├── hash_float.hpp
│ │ │ │ │ │ │ └── limits.hpp
│ │ │ │ │ │ ├── extensions.hpp
│ │ │ │ │ │ ├── hash.hpp
│ │ │ │ │ │ └── hash_fwd.hpp
│ │ │ │ │ ├── hash.hpp
│ │ │ │ │ ├── hash_fwd.hpp
│ │ │ │ │ ├── lightweight_forward_adapter.hpp
│ │ │ │ │ ├── overloaded_function/
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ └── detail/
│ │ │ │ │ │ ├── base.hpp
│ │ │ │ │ │ └── function_type.hpp
│ │ │ │ │ ├── overloaded_function.hpp
│ │ │ │ │ └── value_factory.hpp
│ │ │ │ ├── functional.hpp
│ │ │ │ ├── fusion/
│ │ │ │ │ ├── adapted/
│ │ │ │ │ │ ├── adt/
│ │ │ │ │ │ │ ├── adapt_adt.hpp
│ │ │ │ │ │ │ ├── adapt_adt_named.hpp
│ │ │ │ │ │ │ ├── adapt_assoc_adt.hpp
│ │ │ │ │ │ │ ├── adapt_assoc_adt_named.hpp
│ │ │ │ │ │ │ └── detail/
│ │ │ │ │ │ │ ├── adapt_base.hpp
│ │ │ │ │ │ │ ├── adapt_base_assoc_attr_filler.hpp
│ │ │ │ │ │ │ ├── adapt_base_attr_filler.hpp
│ │ │ │ │ │ │ └── extension.hpp
│ │ │ │ │ │ ├── adt.hpp
│ │ │ │ │ │ ├── array/
│ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ ├── tag_of.hpp
│ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ ├── array.hpp
│ │ │ │ │ │ ├── boost_array/
│ │ │ │ │ │ │ ├── array_iterator.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ └── tag_of.hpp
│ │ │ │ │ │ ├── boost_array.hpp
│ │ │ │ │ │ ├── boost_tuple/
│ │ │ │ │ │ │ ├── boost_tuple_iterator.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_cons.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ ├── mpl/
│ │ │ │ │ │ │ │ └── clear.hpp
│ │ │ │ │ │ │ └── tag_of.hpp
│ │ │ │ │ │ ├── boost_tuple.hpp
│ │ │ │ │ │ ├── mpl/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── empty_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── has_key_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ └── mpl_iterator.hpp
│ │ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ │ ├── std_array/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── array_size.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ ├── std_array_iterator.hpp
│ │ │ │ │ │ │ └── tag_of.hpp
│ │ │ │ │ │ ├── std_array.hpp
│ │ │ │ │ │ ├── std_pair.hpp
│ │ │ │ │ │ ├── std_tuple/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_std_tuple.hpp
│ │ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ ├── mpl/
│ │ │ │ │ │ │ │ └── clear.hpp
│ │ │ │ │ │ │ ├── std_tuple_iterator.hpp
│ │ │ │ │ │ │ └── tag_of.hpp
│ │ │ │ │ │ ├── std_tuple.hpp
│ │ │ │ │ │ ├── struct/
│ │ │ │ │ │ │ ├── adapt_assoc_struct.hpp
│ │ │ │ │ │ │ ├── adapt_assoc_struct_named.hpp
│ │ │ │ │ │ │ ├── adapt_struct.hpp
│ │ │ │ │ │ │ ├── adapt_struct_named.hpp
│ │ │ │ │ │ │ ├── define_assoc_struct.hpp
│ │ │ │ │ │ │ ├── define_struct.hpp
│ │ │ │ │ │ │ ├── define_struct_inline.hpp
│ │ │ │ │ │ │ └── detail/
│ │ │ │ │ │ │ ├── adapt_auto.hpp
│ │ │ │ │ │ │ ├── adapt_base.hpp
│ │ │ │ │ │ │ ├── adapt_base_assoc_attr_filler.hpp
│ │ │ │ │ │ │ ├── adapt_base_attr_filler.hpp
│ │ │ │ │ │ │ ├── adapt_is_tpl.hpp
│ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ ├── category_of_impl.hpp
│ │ │ │ │ │ │ ├── define_struct.hpp
│ │ │ │ │ │ │ ├── define_struct_inline.hpp
│ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ ├── extension.hpp
│ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ ├── is_view_impl.hpp
│ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ ├── namespace.hpp
│ │ │ │ │ │ │ ├── preprocessor/
│ │ │ │ │ │ │ │ └── is_seq.hpp
│ │ │ │ │ │ │ ├── proxy_type.hpp
│ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ └── struct.hpp
│ │ │ │ │ ├── adapted.hpp
│ │ │ │ │ ├── algorithm/
│ │ │ │ │ │ ├── auxiliary/
│ │ │ │ │ │ │ ├── copy.hpp
│ │ │ │ │ │ │ └── move.hpp
│ │ │ │ │ │ ├── auxiliary.hpp
│ │ │ │ │ │ ├── iteration/
│ │ │ │ │ │ │ ├── accumulate.hpp
│ │ │ │ │ │ │ ├── accumulate_fwd.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ │ │ │ ├── iter_fold.hpp
│ │ │ │ │ │ │ │ │ ├── reverse_fold.hpp
│ │ │ │ │ │ │ │ │ └── reverse_iter_fold.hpp
│ │ │ │ │ │ │ │ ├── segmented_fold.hpp
│ │ │ │ │ │ │ │ └── segmented_for_each.hpp
│ │ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ │ ├── fold_fwd.hpp
│ │ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ │ ├── for_each_fwd.hpp
│ │ │ │ │ │ │ ├── iter_fold.hpp
│ │ │ │ │ │ │ ├── iter_fold_fwd.hpp
│ │ │ │ │ │ │ ├── reverse_fold.hpp
│ │ │ │ │ │ │ ├── reverse_fold_fwd.hpp
│ │ │ │ │ │ │ ├── reverse_iter_fold.hpp
│ │ │ │ │ │ │ └── reverse_iter_fold_fwd.hpp
│ │ │ │ │ │ ├── iteration.hpp
│ │ │ │ │ │ ├── query/
│ │ │ │ │ │ │ ├── all.hpp
│ │ │ │ │ │ │ ├── any.hpp
│ │ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ │ ├── count_if.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── all.hpp
│ │ │ │ │ │ │ │ ├── any.hpp
│ │ │ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ │ │ ├── count_if.hpp
│ │ │ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ │ │ ├── segmented_find.hpp
│ │ │ │ │ │ │ │ └── segmented_find_if.hpp
│ │ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ │ ├── find_fwd.hpp
│ │ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ │ ├── find_if_fwd.hpp
│ │ │ │ │ │ │ └── none.hpp
│ │ │ │ │ │ ├── query.hpp
│ │ │ │ │ │ ├── transformation/
│ │ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ ├── zip.hpp
│ │ │ │ │ │ │ │ │ ├── zip10.hpp
│ │ │ │ │ │ │ │ │ ├── zip20.hpp
│ │ │ │ │ │ │ │ │ ├── zip30.hpp
│ │ │ │ │ │ │ │ │ ├── zip40.hpp
│ │ │ │ │ │ │ │ │ └── zip50.hpp
│ │ │ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ │ │ └── replace_if.hpp
│ │ │ │ │ │ │ ├── erase.hpp
│ │ │ │ │ │ │ ├── erase_key.hpp
│ │ │ │ │ │ │ ├── filter.hpp
│ │ │ │ │ │ │ ├── filter_if.hpp
│ │ │ │ │ │ │ ├── flatten.hpp
│ │ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ │ ├── insert_range.hpp
│ │ │ │ │ │ │ ├── join.hpp
│ │ │ │ │ │ │ ├── pop_back.hpp
│ │ │ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ │ ├── remove.hpp
│ │ │ │ │ │ │ ├── remove_if.hpp
│ │ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ │ ├── replace_if.hpp
│ │ │ │ │ │ │ ├── reverse.hpp
│ │ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ │ └── zip.hpp
│ │ │ │ │ │ └── transformation.hpp
│ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ ├── container/
│ │ │ │ │ │ ├── deque/
│ │ │ │ │ │ │ ├── back_extended_deque.hpp
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ ├── deque_fwd.hpp
│ │ │ │ │ │ │ ├── deque_iterator.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_deque.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── as_deque.hpp
│ │ │ │ │ │ │ │ │ ├── build_deque.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── deque_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ ├── deque_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values_call.hpp
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ └── preprocessed/
│ │ │ │ │ │ │ │ │ ├── as_deque.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque10.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque20.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque30.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque40.hpp
│ │ │ │ │ │ │ │ │ ├── as_deque50.hpp
│ │ │ │ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ │ │ │ ├── deque10.hpp
│ │ │ │ │ │ │ │ │ ├── deque10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque20.hpp
│ │ │ │ │ │ │ │ │ ├── deque20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque30.hpp
│ │ │ │ │ │ │ │ │ ├── deque30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque40.hpp
│ │ │ │ │ │ │ │ │ ├── deque40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque50.hpp
│ │ │ │ │ │ │ │ │ ├── deque50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size10.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size20.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size30.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size40.hpp
│ │ │ │ │ │ │ │ │ ├── deque_initial_size50.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values10.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values20.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values30.hpp
│ │ │ │ │ │ │ │ │ ├── deque_keyed_values40.hpp
│ │ │ │ │ │ │ │ │ └── deque_keyed_values50.hpp
│ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp
│ │ │ │ │ │ │ │ ├── keyed_element.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ └── front_extended_deque.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── generation/
│ │ │ │ │ │ │ ├── cons_tie.hpp
│ │ │ │ │ │ │ ├── deque_tie.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── pp_deque_tie.hpp
│ │ │ │ │ │ │ │ ├── pp_list_tie.hpp
│ │ │ │ │ │ │ │ ├── pp_make_deque.hpp
│ │ │ │ │ │ │ │ ├── pp_make_list.hpp
│ │ │ │ │ │ │ │ ├── pp_make_map.hpp
│ │ │ │ │ │ │ │ ├── pp_make_set.hpp
│ │ │ │ │ │ │ │ ├── pp_make_vector.hpp
│ │ │ │ │ │ │ │ ├── pp_map_tie.hpp
│ │ │ │ │ │ │ │ ├── pp_vector_tie.hpp
│ │ │ │ │ │ │ │ └── preprocessed/
│ │ │ │ │ │ │ │ ├── deque_tie.hpp
│ │ │ │ │ │ │ │ ├── deque_tie10.hpp
│ │ │ │ │ │ │ │ ├── deque_tie20.hpp
│ │ │ │ │ │ │ │ ├── deque_tie30.hpp
│ │ │ │ │ │ │ │ ├── deque_tie40.hpp
│ │ │ │ │ │ │ │ ├── deque_tie50.hpp
│ │ │ │ │ │ │ │ ├── list_tie.hpp
│ │ │ │ │ │ │ │ ├── list_tie10.hpp
│ │ │ │ │ │ │ │ ├── list_tie20.hpp
│ │ │ │ │ │ │ │ ├── list_tie30.hpp
│ │ │ │ │ │ │ │ ├── list_tie40.hpp
│ │ │ │ │ │ │ │ ├── list_tie50.hpp
│ │ │ │ │ │ │ │ ├── make_deque.hpp
│ │ │ │ │ │ │ │ ├── make_deque10.hpp
│ │ │ │ │ │ │ │ ├── make_deque20.hpp
│ │ │ │ │ │ │ │ ├── make_deque30.hpp
│ │ │ │ │ │ │ │ ├── make_deque40.hpp
│ │ │ │ │ │ │ │ ├── make_deque50.hpp
│ │ │ │ │ │ │ │ ├── make_list.hpp
│ │ │ │ │ │ │ │ ├── make_list10.hpp
│ │ │ │ │ │ │ │ ├── make_list20.hpp
│ │ │ │ │ │ │ │ ├── make_list30.hpp
│ │ │ │ │ │ │ │ ├── make_list40.hpp
│ │ │ │ │ │ │ │ ├── make_list50.hpp
│ │ │ │ │ │ │ │ ├── make_map.hpp
│ │ │ │ │ │ │ │ ├── make_map10.hpp
│ │ │ │ │ │ │ │ ├── make_map20.hpp
│ │ │ │ │ │ │ │ ├── make_map30.hpp
│ │ │ │ │ │ │ │ ├── make_map40.hpp
│ │ │ │ │ │ │ │ ├── make_map50.hpp
│ │ │ │ │ │ │ │ ├── make_set.hpp
│ │ │ │ │ │ │ │ ├── make_set10.hpp
│ │ │ │ │ │ │ │ ├── make_set20.hpp
│ │ │ │ │ │ │ │ ├── make_set30.hpp
│ │ │ │ │ │ │ │ ├── make_set40.hpp
│ │ │ │ │ │ │ │ ├── make_set50.hpp
│ │ │ │ │ │ │ │ ├── make_vector.hpp
│ │ │ │ │ │ │ │ ├── make_vector10.hpp
│ │ │ │ │ │ │ │ ├── make_vector20.hpp
│ │ │ │ │ │ │ │ ├── make_vector30.hpp
│ │ │ │ │ │ │ │ ├── make_vector40.hpp
│ │ │ │ │ │ │ │ ├── make_vector50.hpp
│ │ │ │ │ │ │ │ ├── map_tie.hpp
│ │ │ │ │ │ │ │ ├── map_tie10.hpp
│ │ │ │ │ │ │ │ ├── map_tie20.hpp
│ │ │ │ │ │ │ │ ├── map_tie30.hpp
│ │ │ │ │ │ │ │ ├── map_tie40.hpp
│ │ │ │ │ │ │ │ ├── map_tie50.hpp
│ │ │ │ │ │ │ │ ├── vector_tie.hpp
│ │ │ │ │ │ │ │ ├── vector_tie10.hpp
│ │ │ │ │ │ │ │ ├── vector_tie20.hpp
│ │ │ │ │ │ │ │ ├── vector_tie30.hpp
│ │ │ │ │ │ │ │ ├── vector_tie40.hpp
│ │ │ │ │ │ │ │ └── vector_tie50.hpp
│ │ │ │ │ │ │ ├── ignore.hpp
│ │ │ │ │ │ │ ├── list_tie.hpp
│ │ │ │ │ │ │ ├── make_cons.hpp
│ │ │ │ │ │ │ ├── make_deque.hpp
│ │ │ │ │ │ │ ├── make_list.hpp
│ │ │ │ │ │ │ ├── make_map.hpp
│ │ │ │ │ │ │ ├── make_set.hpp
│ │ │ │ │ │ │ ├── make_vector.hpp
│ │ │ │ │ │ │ ├── map_tie.hpp
│ │ │ │ │ │ │ ├── pair_tie.hpp
│ │ │ │ │ │ │ └── vector_tie.hpp
│ │ │ │ │ │ ├── generation.hpp
│ │ │ │ │ │ ├── list/
│ │ │ │ │ │ │ ├── cons.hpp
│ │ │ │ │ │ │ ├── cons_fwd.hpp
│ │ │ │ │ │ │ ├── cons_iterator.hpp
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_cons.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons_call.hpp
│ │ │ │ │ │ │ │ │ └── preprocessed/
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ │ │ │ ├── list10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ │ │ │ ├── list20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ │ │ │ ├── list30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ │ │ │ ├── list40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ │ │ │ ├── list50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons10.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons20.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons30.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons40.hpp
│ │ │ │ │ │ │ │ │ └── list_to_cons50.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── empty_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── list_forward_ctor.hpp
│ │ │ │ │ │ │ │ ├── list_to_cons.hpp
│ │ │ │ │ │ │ │ ├── list_to_cons_call.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ │ │ │ ├── list10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ │ │ │ ├── list20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ │ │ │ ├── list30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ │ │ │ ├── list40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ │ │ │ ├── list50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons10.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons20.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons30.hpp
│ │ │ │ │ │ │ │ │ ├── list_to_cons40.hpp
│ │ │ │ │ │ │ │ │ └── list_to_cons50.hpp
│ │ │ │ │ │ │ │ ├── reverse_cons.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ │ └── nil.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── map/
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── at_key_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── build_map.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── as_map.hpp
│ │ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ ├── map_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ ├── map_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ │ ├── as_map.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map10.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map20.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map30.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map40.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_map50.hpp
│ │ │ │ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ │ │ │ ├── map10.hpp
│ │ │ │ │ │ │ │ │ │ ├── map10_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── map20.hpp
│ │ │ │ │ │ │ │ │ │ ├── map20_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── map30.hpp
│ │ │ │ │ │ │ │ │ │ ├── map30_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── map40.hpp
│ │ │ │ │ │ │ │ │ │ ├── map40_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── map50.hpp
│ │ │ │ │ │ │ │ │ │ ├── map50_fwd.hpp
│ │ │ │ │ │ │ │ │ │ └── map_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── map_impl.hpp
│ │ │ │ │ │ │ │ ├── map_index.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_key_impl.hpp
│ │ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ │ ├── map_fwd.hpp
│ │ │ │ │ │ │ └── map_iterator.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── set/
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set10.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set20.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set30.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set40.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_set50.hpp
│ │ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ │ ├── set10.hpp
│ │ │ │ │ │ │ │ │ │ ├── set10_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── set20.hpp
│ │ │ │ │ │ │ │ │ │ ├── set20_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── set30.hpp
│ │ │ │ │ │ │ │ │ │ ├── set30_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── set40.hpp
│ │ │ │ │ │ │ │ │ │ ├── set40_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── set50.hpp
│ │ │ │ │ │ │ │ │ │ ├── set50_fwd.hpp
│ │ │ │ │ │ │ │ │ │ └── set_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ └── set_fwd.hpp
│ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ │ │ │ ├── as_set10.hpp
│ │ │ │ │ │ │ │ │ ├── as_set20.hpp
│ │ │ │ │ │ │ │ │ ├── as_set30.hpp
│ │ │ │ │ │ │ │ │ ├── as_set40.hpp
│ │ │ │ │ │ │ │ │ ├── as_set50.hpp
│ │ │ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ │ │ ├── set10.hpp
│ │ │ │ │ │ │ │ │ ├── set10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── set20.hpp
│ │ │ │ │ │ │ │ │ ├── set20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── set30.hpp
│ │ │ │ │ │ │ │ │ ├── set30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── set40.hpp
│ │ │ │ │ │ │ │ │ ├── set40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── set50.hpp
│ │ │ │ │ │ │ │ │ ├── set50_fwd.hpp
│ │ │ │ │ │ │ │ │ └── set_fwd.hpp
│ │ │ │ │ │ │ │ ├── set_forward_ctor.hpp
│ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ │ └── set_fwd.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── vector/
│ │ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ │ │ ├── convert_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector10.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector20.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector30.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector40.hpp
│ │ │ │ │ │ │ │ │ │ ├── as_vector50.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser10.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser20.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser30.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser40.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_chooser50.hpp
│ │ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector10.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector10_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector20.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector20_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector30.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector30_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector40.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector40_fwd.hpp
│ │ │ │ │ │ │ │ │ │ ├── vvector50.hpp
│ │ │ │ │ │ │ │ │ │ └── vvector50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector_forward_ctor.hpp
│ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector_n.hpp
│ │ │ │ │ │ │ │ │ └── vector_n_chooser.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ │ │ │ ├── as_vector10.hpp
│ │ │ │ │ │ │ │ │ ├── as_vector20.hpp
│ │ │ │ │ │ │ │ │ ├── as_vector30.hpp
│ │ │ │ │ │ │ │ │ ├── as_vector40.hpp
│ │ │ │ │ │ │ │ │ ├── as_vector50.hpp
│ │ │ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vector_chooser.hpp
│ │ │ │ │ │ │ │ │ ├── vector_chooser10.hpp
│ │ │ │ │ │ │ │ │ ├── vector_chooser20.hpp
│ │ │ │ │ │ │ │ │ ├── vector_chooser30.hpp
│ │ │ │ │ │ │ │ │ ├── vector_chooser40.hpp
│ │ │ │ │ │ │ │ │ ├── vector_chooser50.hpp
│ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vvector10.hpp
│ │ │ │ │ │ │ │ │ ├── vvector10_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vvector20.hpp
│ │ │ │ │ │ │ │ │ ├── vvector20_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vvector30.hpp
│ │ │ │ │ │ │ │ │ ├── vvector30_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vvector40.hpp
│ │ │ │ │ │ │ │ │ ├── vvector40_fwd.hpp
│ │ │ │ │ │ │ │ │ ├── vvector50.hpp
│ │ │ │ │ │ │ │ │ └── vvector50_fwd.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ ├── value_of_impl.hpp
│ │ │ │ │ │ │ │ ├── vector_forward_ctor.hpp
│ │ │ │ │ │ │ │ ├── vector_n.hpp
│ │ │ │ │ │ │ │ └── vector_n_chooser.hpp
│ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ │ ├── vector10_fwd.hpp
│ │ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ │ ├── vector20_fwd.hpp
│ │ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ │ ├── vector30_fwd.hpp
│ │ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ │ ├── vector40_fwd.hpp
│ │ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ │ ├── vector50_fwd.hpp
│ │ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ │ └── vector_iterator.hpp
│ │ │ │ │ │ └── vector.hpp
│ │ │ │ │ ├── container.hpp
│ │ │ │ │ ├── functional/
│ │ │ │ │ │ ├── adapter/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── access.hpp
│ │ │ │ │ │ │ ├── fused.hpp
│ │ │ │ │ │ │ ├── fused_function_object.hpp
│ │ │ │ │ │ │ ├── fused_procedure.hpp
│ │ │ │ │ │ │ ├── limits.hpp
│ │ │ │ │ │ │ ├── unfused.hpp
│ │ │ │ │ │ │ └── unfused_typed.hpp
│ │ │ │ │ │ ├── adapter.hpp
│ │ │ │ │ │ ├── generation/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── gen_make_adapter.hpp
│ │ │ │ │ │ │ ├── make_fused.hpp
│ │ │ │ │ │ │ ├── make_fused_function_object.hpp
│ │ │ │ │ │ │ ├── make_fused_procedure.hpp
│ │ │ │ │ │ │ └── make_unfused.hpp
│ │ │ │ │ │ ├── generation.hpp
│ │ │ │ │ │ ├── invocation/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ └── that_ptr.hpp
│ │ │ │ │ │ │ ├── invoke.hpp
│ │ │ │ │ │ │ ├── invoke_function_object.hpp
│ │ │ │ │ │ │ ├── invoke_procedure.hpp
│ │ │ │ │ │ │ └── limits.hpp
│ │ │ │ │ │ └── invocation.hpp
│ │ │ │ │ ├── functional.hpp
│ │ │ │ │ ├── include/
│ │ │ │ │ │ ├── accumulate.hpp
│ │ │ │ │ │ ├── adapt_adt.hpp
│ │ │ │ │ │ ├── adapt_adt_named.cpp
│ │ │ │ │ │ ├── adapt_adt_named.hpp
│ │ │ │ │ │ ├── adapt_assoc_adt.hpp
│ │ │ │ │ │ ├── adapt_assoc_adt_named.hpp
│ │ │ │ │ │ ├── adapt_assoc_class.hpp
│ │ │ │ │ │ ├── adapt_assoc_class_named.hpp
│ │ │ │ │ │ ├── adapt_assoc_struct.hpp
│ │ │ │ │ │ ├── adapt_assoc_struct_named.hpp
│ │ │ │ │ │ ├── adapt_struct.hpp
│ │ │ │ │ │ ├── adapt_struct_named.hpp
│ │ │ │ │ │ ├── adapted.hpp
│ │ │ │ │ │ ├── adapter.hpp
│ │ │ │ │ │ ├── advance.hpp
│ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ ├── all.hpp
│ │ │ │ │ │ ├── any.hpp
│ │ │ │ │ │ ├── array.hpp
│ │ │ │ │ │ ├── as_deque.hpp
│ │ │ │ │ │ ├── as_list.hpp
│ │ │ │ │ │ ├── as_map.hpp
│ │ │ │ │ │ ├── as_set.hpp
│ │ │ │ │ │ ├── as_vector.hpp
│ │ │ │ │ │ ├── at.hpp
│ │ │ │ │ │ ├── at_c.hpp
│ │ │ │ │ │ ├── at_key.hpp
│ │ │ │ │ │ ├── auxiliary.hpp
│ │ │ │ │ │ ├── back.hpp
│ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ ├── boost_array.hpp
│ │ │ │ │ │ ├── boost_tuple.hpp
│ │ │ │ │ │ ├── category_of.hpp
│ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ ├── comparison.hpp
│ │ │ │ │ │ ├── cons.hpp
│ │ │ │ │ │ ├── cons_tie.hpp
│ │ │ │ │ │ ├── container.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── copy.hpp
│ │ │ │ │ │ ├── count.hpp
│ │ │ │ │ │ ├── count_if.hpp
│ │ │ │ │ │ ├── deduce.hpp
│ │ │ │ │ │ ├── deduce_sequence.hpp
│ │ │ │ │ │ ├── define_assoc_struct.hpp
│ │ │ │ │ │ ├── define_struct.hpp
│ │ │ │ │ │ ├── define_struct_inline.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── deque_fwd.hpp
│ │ │ │ │ │ ├── deque_tie.hpp
│ │ │ │ │ │ ├── deref.hpp
│ │ │ │ │ │ ├── deref_data.hpp
│ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ ├── end.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── erase.hpp
│ │ │ │ │ │ ├── erase_key.hpp
│ │ │ │ │ │ ├── filter.hpp
│ │ │ │ │ │ ├── filter_if.hpp
│ │ │ │ │ │ ├── filter_view.hpp
│ │ │ │ │ │ ├── find.hpp
│ │ │ │ │ │ ├── find_if.hpp
│ │ │ │ │ │ ├── flatten.hpp
│ │ │ │ │ │ ├── flatten_view.hpp
│ │ │ │ │ │ ├── fold.hpp
│ │ │ │ │ │ ├── for_each.hpp
│ │ │ │ │ │ ├── front.hpp
│ │ │ │ │ │ ├── functional.hpp
│ │ │ │ │ │ ├── fused.hpp
│ │ │ │ │ │ ├── fused_function_object.hpp
│ │ │ │ │ │ ├── fused_procedure.hpp
│ │ │ │ │ │ ├── generation.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── has_key.hpp
│ │ │ │ │ │ ├── hash.hpp
│ │ │ │ │ │ ├── ignore.hpp
│ │ │ │ │ │ ├── in.hpp
│ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ ├── insert_range.hpp
│ │ │ │ │ │ ├── intrinsic.hpp
│ │ │ │ │ │ ├── invocation.hpp
│ │ │ │ │ │ ├── invoke.hpp
│ │ │ │ │ │ ├── invoke_function_object.hpp
│ │ │ │ │ │ ├── invoke_procedure.hpp
│ │ │ │ │ │ ├── io.hpp
│ │ │ │ │ │ ├── is_iterator.hpp
│ │ │ │ │ │ ├── is_segmented.hpp
│ │ │ │ │ │ ├── is_sequence.hpp
│ │ │ │ │ │ ├── is_view.hpp
│ │ │ │ │ │ ├── iter_fold.hpp
│ │ │ │ │ │ ├── iteration.hpp
│ │ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ │ ├── iterator_adapter.hpp
│ │ │ │ │ │ ├── iterator_base.hpp
│ │ │ │ │ │ ├── iterator_facade.hpp
│ │ │ │ │ │ ├── iterator_range.hpp
│ │ │ │ │ │ ├── join.hpp
│ │ │ │ │ │ ├── joint_view.hpp
│ │ │ │ │ │ ├── key_of.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_fwd.hpp
│ │ │ │ │ │ ├── list_tie.hpp
│ │ │ │ │ │ ├── make_cons.hpp
│ │ │ │ │ │ ├── make_deque.hpp
│ │ │ │ │ │ ├── make_fused.hpp
│ │ │ │ │ │ ├── make_fused_function_object.hpp
│ │ │ │ │ │ ├── make_fused_procedure.hpp
│ │ │ │ │ │ ├── make_list.hpp
│ │ │ │ │ │ ├── make_map.hpp
│ │ │ │ │ │ ├── make_set.hpp
│ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ ├── make_unfused.hpp
│ │ │ │ │ │ ├── make_vector.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── map_fwd.hpp
│ │ │ │ │ │ ├── map_tie.hpp
│ │ │ │ │ │ ├── move.hpp
│ │ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ │ ├── next.hpp
│ │ │ │ │ │ ├── nil.hpp
│ │ │ │ │ │ ├── none.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── nview.hpp
│ │ │ │ │ │ ├── out.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── pair_tie.hpp
│ │ │ │ │ │ ├── pop_back.hpp
│ │ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ │ ├── prior.hpp
│ │ │ │ │ │ ├── proxy_type.hpp
│ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ ├── query.hpp
│ │ │ │ │ │ ├── remove.hpp
│ │ │ │ │ │ ├── remove_if.hpp
│ │ │ │ │ │ ├── repetitive_view.hpp
│ │ │ │ │ │ ├── replace.hpp
│ │ │ │ │ │ ├── replace_if.hpp
│ │ │ │ │ │ ├── reverse.hpp
│ │ │ │ │ │ ├── reverse_fold.hpp
│ │ │ │ │ │ ├── reverse_iter_fold.hpp
│ │ │ │ │ │ ├── reverse_view.hpp
│ │ │ │ │ │ ├── segmented_fold_until.hpp
│ │ │ │ │ │ ├── segmented_iterator.hpp
│ │ │ │ │ │ ├── segments.hpp
│ │ │ │ │ │ ├── sequence.hpp
│ │ │ │ │ │ ├── sequence_base.hpp
│ │ │ │ │ │ ├── sequence_facade.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_fwd.hpp
│ │ │ │ │ │ ├── single_view.hpp
│ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ ├── std_pair.hpp
│ │ │ │ │ │ ├── std_tuple.hpp
│ │ │ │ │ │ ├── struct.hpp
│ │ │ │ │ │ ├── support.hpp
│ │ │ │ │ │ ├── swap.hpp
│ │ │ │ │ │ ├── tag_of.hpp
│ │ │ │ │ │ ├── tag_of_fwd.hpp
│ │ │ │ │ │ ├── transform.hpp
│ │ │ │ │ │ ├── transform_view.hpp
│ │ │ │ │ │ ├── transformation.hpp
│ │ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ │ ├── tuple_fwd.hpp
│ │ │ │ │ │ ├── tuple_tie.hpp
│ │ │ │ │ │ ├── unfused.hpp
│ │ │ │ │ │ ├── unfused_typed.hpp
│ │ │ │ │ │ ├── unused.hpp
│ │ │ │ │ │ ├── value_at.hpp
│ │ │ │ │ │ ├── value_at_key.hpp
│ │ │ │ │ │ ├── value_of.hpp
│ │ │ │ │ │ ├── value_of_data.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ ├── vector10.hpp
│ │ │ │ │ │ ├── vector20.hpp
│ │ │ │ │ │ ├── vector30.hpp
│ │ │ │ │ │ ├── vector40.hpp
│ │ │ │ │ │ ├── vector50.hpp
│ │ │ │ │ │ ├── vector_fwd.hpp
│ │ │ │ │ │ ├── vector_tie.hpp
│ │ │ │ │ │ ├── view.hpp
│ │ │ │ │ │ ├── void.hpp
│ │ │ │ │ │ ├── zip.hpp
│ │ │ │ │ │ └── zip_view.hpp
│ │ │ │ │ ├── iterator/
│ │ │ │ │ │ ├── advance.hpp
│ │ │ │ │ │ ├── basic_iterator.hpp
│ │ │ │ │ │ ├── deref.hpp
│ │ │ │ │ │ ├── deref_data.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── adapt_deref_traits.hpp
│ │ │ │ │ │ │ ├── adapt_value_traits.hpp
│ │ │ │ │ │ │ ├── advance.hpp
│ │ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ │ ├── segment_sequence.hpp
│ │ │ │ │ │ │ ├── segmented_equal_to.hpp
│ │ │ │ │ │ │ ├── segmented_iterator.hpp
│ │ │ │ │ │ │ └── segmented_next_impl.hpp
│ │ │ │ │ │ ├── distance.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── iterator_adapter.hpp
│ │ │ │ │ │ ├── iterator_facade.hpp
│ │ │ │ │ │ ├── key_of.hpp
│ │ │ │ │ │ ├── mpl/
│ │ │ │ │ │ │ ├── convert_iterator.hpp
│ │ │ │ │ │ │ └── fusion_iterator.hpp
│ │ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ │ ├── next.hpp
│ │ │ │ │ │ ├── prior.hpp
│ │ │ │ │ │ ├── segmented_iterator.hpp
│ │ │ │ │ │ ├── value_of.hpp
│ │ │ │ │ │ └── value_of_data.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── mpl/
│ │ │ │ │ │ ├── at.hpp
│ │ │ │ │ │ ├── back.hpp
│ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ ├── clear.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── clear.hpp
│ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ ├── end.hpp
│ │ │ │ │ │ ├── erase.hpp
│ │ │ │ │ │ ├── erase_key.hpp
│ │ │ │ │ │ ├── front.hpp
│ │ │ │ │ │ ├── has_key.hpp
│ │ │ │ │ │ ├── insert.hpp
│ │ │ │ │ │ ├── insert_range.hpp
│ │ │ │ │ │ ├── pop_back.hpp
│ │ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ │ └── size.hpp
│ │ │ │ │ ├── mpl.hpp
│ │ │ │ │ ├── sequence/
│ │ │ │ │ │ ├── comparison/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ │ └── not_equal_to.hpp
│ │ │ │ │ │ │ ├── enable_comparison.hpp
│ │ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ │ └── not_equal_to.hpp
│ │ │ │ │ │ ├── comparison.hpp
│ │ │ │ │ │ ├── convert.hpp
│ │ │ │ │ │ ├── hash.hpp
│ │ │ │ │ │ ├── intrinsic/
│ │ │ │ │ │ │ ├── at.hpp
│ │ │ │ │ │ │ ├── at_c.hpp
│ │ │ │ │ │ │ ├── at_key.hpp
│ │ │ │ │ │ │ ├── back.hpp
│ │ │ │ │ │ │ ├── begin.hpp
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── segmented_begin.hpp
│ │ │ │ │ │ │ │ ├── segmented_begin_impl.hpp
│ │ │ │ │ │ │ │ ├── segmented_end.hpp
│ │ │ │ │ │ │ │ ├── segmented_end_impl.hpp
│ │ │ │ │ │ │ │ └── segmented_size.hpp
│ │ │ │ │ │ │ ├── empty.hpp
│ │ │ │ │ │ │ ├── end.hpp
│ │ │ │ │ │ │ ├── front.hpp
│ │ │ │ │ │ │ ├── has_key.hpp
│ │ │ │ │ │ │ ├── segments.hpp
│ │ │ │ │ │ │ ├── size.hpp
│ │ │ │ │ │ │ ├── swap.hpp
│ │ │ │ │ │ │ ├── value_at.hpp
│ │ │ │ │ │ │ └── value_at_key.hpp
│ │ │ │ │ │ ├── intrinsic.hpp
│ │ │ │ │ │ ├── intrinsic_fwd.hpp
│ │ │ │ │ │ ├── io/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── in.hpp
│ │ │ │ │ │ │ │ ├── manip.hpp
│ │ │ │ │ │ │ │ └── out.hpp
│ │ │ │ │ │ │ ├── in.hpp
│ │ │ │ │ │ │ └── out.hpp
│ │ │ │ │ │ ├── io.hpp
│ │ │ │ │ │ └── sequence_facade.hpp
│ │ │ │ │ ├── sequence.hpp
│ │ │ │ │ ├── support/
│ │ │ │ │ │ ├── as_const.hpp
│ │ │ │ │ │ ├── category_of.hpp
│ │ │ │ │ │ ├── config.hpp
│ │ │ │ │ │ ├── deduce.hpp
│ │ │ │ │ │ ├── deduce_sequence.hpp
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── access.hpp
│ │ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ │ ├── as_fusion_element.hpp
│ │ │ │ │ │ │ ├── category_of.hpp
│ │ │ │ │ │ │ ├── enabler.hpp
│ │ │ │ │ │ │ ├── index_sequence.hpp
│ │ │ │ │ │ │ ├── is_mpl_sequence.hpp
│ │ │ │ │ │ │ ├── is_same_size.hpp
│ │ │ │ │ │ │ ├── is_view.hpp
│ │ │ │ │ │ │ ├── mpl_iterator_category.hpp
│ │ │ │ │ │ │ ├── pp_round.hpp
│ │ │ │ │ │ │ ├── segmented_fold_until_impl.hpp
│ │ │ │ │ │ │ └── unknown_key.hpp
│ │ │ │ │ │ ├── is_iterator.hpp
│ │ │ │ │ │ ├── is_segmented.hpp
│ │ │ │ │ │ ├── is_sequence.hpp
│ │ │ │ │ │ ├── is_view.hpp
│ │ │ │ │ │ ├── iterator_base.hpp
│ │ │ │ │ │ ├── pair.hpp
│ │ │ │ │ │ ├── segmented_fold_until.hpp
│ │ │ │ │ │ ├── sequence_base.hpp
│ │ │ │ │ │ ├── tag_of.hpp
│ │ │ │ │ │ ├── tag_of_fwd.hpp
│ │ │ │ │ │ ├── unused.hpp
│ │ │ │ │ │ └── void.hpp
│ │ │ │ │ ├── support.hpp
│ │ │ │ │ ├── tuple/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ │ │ ├── make_tuple10.hpp
│ │ │ │ │ │ │ │ ├── make_tuple20.hpp
│ │ │ │ │ │ │ │ ├── make_tuple30.hpp
│ │ │ │ │ │ │ │ ├── make_tuple40.hpp
│ │ │ │ │ │ │ │ ├── make_tuple50.hpp
│ │ │ │ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ │ │ │ ├── tuple10.hpp
│ │ │ │ │ │ │ │ ├── tuple10_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple20.hpp
│ │ │ │ │ │ │ │ ├── tuple20_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple30.hpp
│ │ │ │ │ │ │ │ ├── tuple30_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple40.hpp
│ │ │ │ │ │ │ │ ├── tuple40_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple50.hpp
│ │ │ │ │ │ │ │ ├── tuple50_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple_fwd.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie10.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie20.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie30.hpp
│ │ │ │ │ │ │ │ ├── tuple_tie40.hpp
│ │ │ │ │ │ │ │ └── tuple_tie50.hpp
│ │ │ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ │ │ ├── tuple_expand.hpp
│ │ │ │ │ │ │ ├── tuple_fwd.hpp
│ │ │ │ │ │ │ └── tuple_tie.hpp
│ │ │ │ │ │ ├── make_tuple.hpp
│ │ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ │ ├── tuple_fwd.hpp
│ │ │ │ │ │ └── tuple_tie.hpp
│ │ │ │ │ ├── tuple.hpp
│ │ │ │ │ ├── view/
│ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ └── strictest_traversal.hpp
│ │ │ │ │ │ ├── filter_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── filter_view.hpp
│ │ │ │ │ │ │ └── filter_view_iterator.hpp
│ │ │ │ │ │ ├── filter_view.hpp
│ │ │ │ │ │ ├── flatten_view/
│ │ │ │ │ │ │ ├── flatten_view.hpp
│ │ │ │ │ │ │ └── flatten_view_iterator.hpp
│ │ │ │ │ │ ├── flatten_view.hpp
│ │ │ │ │ │ ├── iterator_range/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── is_segmented_impl.hpp
│ │ │ │ │ │ │ │ ├── segmented_iterator_range.hpp
│ │ │ │ │ │ │ │ ├── segments_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ └── value_at_impl.hpp
│ │ │ │ │ │ │ └── iterator_range.hpp
│ │ │ │ │ │ ├── iterator_range.hpp
│ │ │ │ │ │ ├── joint_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── joint_view.hpp
│ │ │ │ │ │ │ ├── joint_view_fwd.hpp
│ │ │ │ │ │ │ └── joint_view_iterator.hpp
│ │ │ │ │ │ ├── joint_view.hpp
│ │ │ │ │ │ ├── nview/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── cpp03/
│ │ │ │ │ │ │ │ │ └── nview_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── nview_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── nview.hpp
│ │ │ │ │ │ │ └── nview_iterator.hpp
│ │ │ │ │ │ ├── nview.hpp
│ │ │ │ │ │ ├── repetitive_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── repetitive_view.hpp
│ │ │ │ │ │ │ ├── repetitive_view_fwd.hpp
│ │ │ │ │ │ │ └── repetitive_view_iterator.hpp
│ │ │ │ │ │ ├── repetitive_view.hpp
│ │ │ │ │ │ ├── reverse_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_data_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── key_of_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── reverse_view.hpp
│ │ │ │ │ │ │ └── reverse_view_iterator.hpp
│ │ │ │ │ │ ├── reverse_view.hpp
│ │ │ │ │ │ ├── single_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── single_view.hpp
│ │ │ │ │ │ │ └── single_view_iterator.hpp
│ │ │ │ │ │ ├── single_view.hpp
│ │ │ │ │ │ ├── transform_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── apply_transform_result.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_impl.hpp
│ │ │ │ │ │ │ ├── transform_view.hpp
│ │ │ │ │ │ │ ├── transform_view_fwd.hpp
│ │ │ │ │ │ │ └── transform_view_iterator.hpp
│ │ │ │ │ │ ├── transform_view.hpp
│ │ │ │ │ │ ├── zip_view/
│ │ │ │ │ │ │ ├── detail/
│ │ │ │ │ │ │ │ ├── advance_impl.hpp
│ │ │ │ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ │ │ │ ├── begin_impl.hpp
│ │ │ │ │ │ │ │ ├── deref_impl.hpp
│ │ │ │ │ │ │ │ ├── distance_impl.hpp
│ │ │ │ │ │ │ │ ├── end_impl.hpp
│ │ │ │ │ │ │ │ ├── equal_to_impl.hpp
│ │ │ │ │ │ │ │ ├── next_impl.hpp
│ │ │ │ │ │ │ │ ├── prior_impl.hpp
│ │ │ │ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ │ │ │ ├── value_at_impl.hpp
│ │ │ │ │ │ │ │ └── value_of_im
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# OSX
#
.DS_Store
# node.js
#
node_modules/
npm-debug.log
yarn-error.log
# Xcode
#
build/
*.pbxuser
!default.pbxuser
*.mode1v3
!default.mode1v3
*.mode2v3
!default.mode2v3
*.perspectivev3
!default.perspectivev3
xcuserdata
*.xccheckout
*.moved-aside
DerivedData
*.hmap
*.ipa
*.xcuserstate
project.xcworkspace
# Android/IntelliJ
#
build/
.idea
.gradle
local.properties
*.iml
# BUCK
buck-out/
\.buckd/
*.keystore
================================================
FILE: .npmignore
================================================
example/
doc/
docs/
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing
We want this community to be friendly and respectful to each other. Please follow it in all your interactions with the project.
## Development workflow
To get started with the project, run `yarn` in the root directory to install the required dependencies for each package:
```sh
yarn
```
While developing, you can run the [example app](/example/) to test your changes.
To start the packager:
```sh
yarn example start
```
To run the example app on Android:
```sh
yarn example android
```
To run the example app on iOS:
```sh
yarn example ios
```
Make sure your code passes TypeScript and ESLint. Run the following to verify:
```sh
yarn typescript
yarn lint
```
To fix formatting errors, run the following:
```sh
yarn lint --fix
```
Remember to add tests for your change if possible. Run the unit tests by:
```sh
yarn test
```
To edit the Objective-C files, open `example/ios/ReceiveSharingIntentExample.xcworkspace` in XCode and find the source files at `Pods > Development Pods > react-native-receive-sharing-intent`.
To edit the Kotlin files, open `example/android` in Android studio and find the source files at `reactnativereceivesharingintent` under `Android`.
### Commit message convention
We follow the [conventional commits specification](https://www.conventionalcommits.org/en) for our commit messages:
- `fix`: bug fixes, e.g. fix crash due to deprecated method.
- `feat`: new features, e.g. add new method to the module.
- `refactor`: code refactor, e.g. migrate from class components to hooks.
- `docs`: changes into documentation, e.g. add usage example for the module..
- `test`: adding or updating tests, e.g. add integration tests using detox.
- `chore`: tooling changes, e.g. change CI config.
Our pre-commit hooks verify that your commit message matches this format when committing.
### Linting and tests
[ESLint](https://eslint.org/), [Prettier](https://prettier.io/), [TypeScript](https://www.typescriptlang.org/)
We use [TypeScript](https://www.typescriptlang.org/) for type checking, [ESLint](https://eslint.org/) with [Prettier](https://prettier.io/) for linting and formatting the code, and [Jest](https://jestjs.io/) for testing.
Our pre-commit hooks verify that the linter and tests pass when committing.
### Scripts
The `package.json` file contains various scripts for common tasks:
- `yarn bootstrap`: setup project by installing all dependencies and pods.
- `yarn typescript`: type-check files with TypeScript.
- `yarn lint`: lint files with ESLint.
- `yarn test`: run unit tests with Jest.
- `yarn example start`: start the Metro server for the example app.
- `yarn example android`: run the example app on Android.
- `yarn example ios`: run the example app on iOS.
### Sending a pull request
> **Working on your first pull request?** You can learn how from this _free_ series: [How to Contribute to an Open Source Project on GitHub](https://egghead.io/series/how-to-contribute-to-an-open-source-project-on-github).
When you're sending a pull request:
- Prefer small pull requests focused on one change.
- Verify that linters and tests are passing.
- Review the documentation to make sure it looks good.
- Follow the pull request template when opening a pull request.
- For pull requests that change the API or implementation, discuss with maintainers first by opening an issue.
## Code of Conduct
### Our Pledge
We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
### Our Standards
Examples of behavior that contributes to a positive environment for our community include:
- Demonstrating empathy and kindness toward other people
- Being respectful of differing opinions, viewpoints, and experiences
- Giving and gracefully accepting constructive feedback
- Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
- Focusing on what is best not just for us as individuals, but for the overall community
Examples of unacceptable behavior include:
- The use of sexualized language or imagery, and sexual attention or
advances of any kind
- Trolling, insulting or derogatory comments, and personal or political attacks
- Public or private harassment
- Publishing others' private information, such as a physical or email
address, without their explicit permission
- Other conduct which could reasonably be considered inappropriate in a
professional setting
### Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
### Scope
This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
### Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at [INSERT CONTACT METHOD]. All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the reporter of any incident.
### Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
#### 1. Correction
**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
#### 2. Warning
**Community Impact**: A violation through a single incident or series of actions.
**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
#### 3. Temporary Ban
**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
#### 4. Permanent Ban
**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
**Consequence**: A permanent ban from any sort of public interaction within the community.
### Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2020 Ajith A B
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: README.md
================================================
# react-native-receive-sharing-intent
A React Native plugin that enables React Native apps to receive sharing photos, videos, text, urls or any other file types from another app.
Also, supports iOS Share extension and launching the host app automatically. Check the provided example for more info.
## Demo
| Android | Ios |
| :---: | :---: |
| <img height="400" src="https://raw.githubusercontent.com/ajith-ab/react-native-receive-sharing-intent/master/doc/android.gif" />| <img height="400" src="https://raw.githubusercontent.com/ajith-ab/react-native-receive-sharing-intent/master/doc/ios.gif" /> |
## Installation
1. <a href="https://ajith-ab.github.io/react-native-receive-sharing-intent/" >Home Page</a>
2. <a href="https://ajith-ab.github.io/react-native-receive-sharing-intent/docs/intro" >Installation</a>
3. <a href="https://ajith-ab.github.io/react-native-receive-sharing-intent/docs/android" >Android</a>
4. <a href="https://ajith-ab.github.io/react-native-receive-sharing-intent/docs/ios" >IOS</a>
### Donate
<p><a href="https://www.paypal.me/ajithab" rel="nofollow"><img height="75" src="https://raw.githubusercontent.com/stefan-niedermann/paypal-donate-button/master/paypal-donate-button.png" style="max-width:100%;"></a></p>
### Author
[Ajith A B](https://www.linkedin.com/in/ajith-a-b-a61303197)
### licenses
MIT
================================================
FILE: android/build.gradle
================================================
buildscript {
// Buildscript is evaluated before everything else so we can't use getExtOrDefault
def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['ReceiveSharingIntent_kotlinVersion']
repositories {
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.2.1'
// noinspection DifferentKotlinGradleVersion
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'
def getExtOrDefault(name) {
return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReceiveSharingIntent_' + name]
}
def getExtOrIntegerDefault(name) {
return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['ReceiveSharingIntent_' + name]).toInteger()
}
android {
compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
buildToolsVersion getExtOrDefault('buildToolsVersion')
defaultConfig {
minSdkVersion 16
targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
}
}
lintOptions {
disable 'GradleCompatible'
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
repositories {
mavenCentral()
jcenter()
google()
def found = false
def defaultDir = null
def androidSourcesName = 'React Native sources'
if (rootProject.ext.has('reactNativeAndroidRoot')) {
defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
} else {
defaultDir = new File(
projectDir,
'/../../../node_modules/react-native/android'
)
}
if (defaultDir.exists()) {
maven {
url defaultDir.toString()
name androidSourcesName
}
logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
found = true
} else {
def parentDir = rootProject.projectDir
1.upto(5, {
if (found) return true
parentDir = parentDir.parentFile
def androidSourcesDir = new File(
parentDir,
'node_modules/react-native'
)
def androidPrebuiltBinaryDir = new File(
parentDir,
'node_modules/react-native/android'
)
if (androidPrebuiltBinaryDir.exists()) {
maven {
url androidPrebuiltBinaryDir.toString()
name androidSourcesName
}
logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
found = true
} else if (androidSourcesDir.exists()) {
maven {
url androidSourcesDir.toString()
name androidSourcesName
}
logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
found = true
}
})
}
if (!found) {
throw new GradleException(
"${project.name}: unable to locate React Native android sources. " +
"Ensure you have you installed React Native as a dependency in your project and try again."
)
}
}
def kotlin_version = getExtOrDefault('kotlinVersion')
dependencies {
// noinspection GradleDynamicVersion
api 'com.facebook.react:react-native:+'
implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}
================================================
FILE: android/gradle.properties
================================================
ReceiveSharingIntent_kotlinVersion=1.3.50
ReceiveSharingIntent_compileSdkVersion=29
ReceiveSharingIntent_buildToolsVersion=29.0.2
ReceiveSharingIntent_targetSdkVersion=29
================================================
FILE: android/src/main/AndroidManifest.xml
================================================
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.reactnativereceivesharingintent">
</manifest>
================================================
FILE: android/src/main/java/com/reactnativereceivesharingintent/FileDirectory.kt
================================================
package com.reactnativereceivesharingintent;
import android.content.ContentUris
import android.content.Context
import android.database.Cursor
import android.net.Uri
import android.os.Build
import android.os.Environment
import android.provider.DocumentsContract
import android.provider.MediaStore
import java.io.File
import java.io.FileOutputStream
import java.util.*
import android.webkit.MimeTypeMap
import android.util.Log
object FileDirectory {
/**
* Get a file path from a Uri. This will get the the path for Storage Access
* Framework Documents, as well as the _data field for the MediaStore and
* other file-based ContentProviders.
*
* @param context The context.
* @param uri The Uri to query.
* @author paulburke
*/
fun getAbsolutePath(context: Context, uri: Uri): String? {
// DocumentProvider
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, uri)) {
// ExternalStorageProvider
if (isExternalStorageDocument(uri)) {
val docId = DocumentsContract.getDocumentId(uri)
val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
val type = split[0]
return if ("primary".equals(type, ignoreCase = true)) {
Environment.getExternalStorageDirectory().toString() + "/" + split[1]
} else {
getDataColumn(context, uri, null, null)
}
} else if (isDownloadsDocument(uri)) {
return try {
val id = DocumentsContract.getDocumentId(uri)
val contentUri = ContentUris.withAppendedId(
Uri.parse("content://downloads/public_downloads"), java.lang.Long.valueOf(id))
getDataColumn(context, contentUri, null, null)
} catch (exception: Exception) {
getDataColumn(context, uri, null, null)
}
} else if (isMediaDocument(uri)) {
val docId = DocumentsContract.getDocumentId(uri)
val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
val type = split[0]
var contentUri: Uri? = null
when (type) {
"image" -> contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI
"video" -> contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI
"audio" -> contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
}
if (contentUri == null) return null
val selection = "_id=?"
val selectionArgs = arrayOf(split[1])
return getDataColumn(context, contentUri, selection, selectionArgs)
}// MediaProvider
// DownloadsProvider
} else if ("content".equals(uri.scheme, ignoreCase = true)) {
return getDataColumn(context, uri, null, null)
}
return uri.path
}
/**
* Get the value of the data column for this Uri. This is useful for
* MediaStore Uris, and other file-based ContentProviders.
*
* @param context The context.
* @param uri The Uri to query.
* @param selection (Optional) Filter used in the query.
* @param selectionArgs (Optional) Selection arguments used in the query.
* @return The value of the _data column, which is typically a file path.
*/
private fun getDataColumn(context: Context, uri: Uri, selection: String?,
selectionArgs: Array<String>?): String? {
if (uri.authority != null) {
var cursor: Cursor? = null
val column = "_display_name"
val projection = arrayOf(column)
var targetFile: File? = null
try {
cursor = context.contentResolver.query(uri, projection, selection, selectionArgs, null)
if (cursor != null && cursor.moveToFirst()) {
val columnIndex = cursor.getColumnIndexOrThrow(column)
val fileName = cursor.getString(columnIndex)
Log.i("FileDirectory", "File name: $fileName")
targetFile = File(context.cacheDir, fileName)
}
} finally {
cursor?.close()
}
if (targetFile == null) {
val mimeType = context.contentResolver.getType(uri)
val prefix = with(mimeType ?: "") {
when {
startsWith("image") -> "IMG"
startsWith("video") -> "VID"
else -> "FILE"
}
}
val type = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType)
targetFile = File(context.cacheDir, "${prefix}_${Date().time}.$type")
}
context.contentResolver.openInputStream(uri)?.use { input ->
FileOutputStream(targetFile).use { fileOut ->
input.copyTo(fileOut)
}
}
return targetFile.path
}
var cursor: Cursor? = null
val column = "_data"
val projection = arrayOf(column)
try {
cursor = context.contentResolver.query(uri, projection, selection, selectionArgs, null)
if (cursor != null && cursor.moveToFirst()) {
val columnIndex = cursor.getColumnIndexOrThrow(column)
return cursor.getString(columnIndex)
}
} finally {
cursor?.close()
}
return null
}
/**
* @param uri The Uri to check.
* @return Whether the Uri authority is ExternalStorageProvider.
*/
fun isExternalStorageDocument(uri: Uri): Boolean {
return "com.android.externalstorage.documents" == uri.authority
}
/**
* @param uri The Uri to check.
* @return Whether the Uri authority is DownloadsProvider.
*/
fun isDownloadsDocument(uri: Uri): Boolean {
return "com.android.providers.downloads.documents" == uri.authority
}
/**
* @param uri The Uri to check.
* @return Whether the Uri authority is MediaProvider.
*/
fun isMediaDocument(uri: Uri): Boolean {
return "com.android.providers.media.documents" == uri.authority
}
}
================================================
FILE: android/src/main/java/com/reactnativereceivesharingintent/ReceiveSharingIntentHelper.java
================================================
package com.reactnativereceivesharingintent;
import android.app.Application;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.os.Build;
import android.provider.OpenableColumns;
import androidx.annotation.RequiresApi;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.WritableNativeMap;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Objects;
public class ReceiveSharingIntentHelper {
private Context context;
public ReceiveSharingIntentHelper(Application context){
this.context = context;
}
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public void sendFileNames(Context context, Intent intent, Promise promise){
try {
String action = intent.getAction();
String type = intent.getType();
if(type == null) { return; }
if(!type.startsWith("text") && (Objects.equals(action, Intent.ACTION_SEND) || Objects.equals(action, Intent.ACTION_SEND_MULTIPLE))){
WritableMap files = getMediaUris(intent,context);
if(files == null) return;
promise.resolve(files);
}else if(type.startsWith("text") && Objects.equals(action, Intent.ACTION_SEND)){
String text = null;
String subject = null;
try{
text = intent.getStringExtra(Intent.EXTRA_TEXT);
subject = intent.getStringExtra(Intent.EXTRA_SUBJECT);
}catch (Exception ignored){ }
if(text == null){
WritableMap files = getMediaUris(intent,context);
if(files == null) return;
promise.resolve(files);
}else{
WritableMap files = new WritableNativeMap();
WritableMap file = new WritableNativeMap();
file.putString("contentUri",null);
file.putString("filePath", null);
file.putString("fileName", null);
file.putString("extension", null);
if(text.startsWith("http")){
file.putString("weblink", text);
file.putString("text",null);
}else{
file.putString("weblink", null);
file.putString("text",text);
}
file.putString("subject", subject);
files.putMap("0",file);
promise.resolve(files);
}
}else if(Objects.equals(action, Intent.ACTION_VIEW)){
String link = intent.getDataString();
WritableMap files = new WritableNativeMap();
WritableMap file = new WritableNativeMap();
file.putString("contentUri",null);
file.putString("filePath", null);
file.putString("mimeType",null);
file.putString("text",null);
file.putString("weblink", link);
file.putString("fileName", null);
file.putString("extension", null);
files.putMap("0",file);
promise.resolve(files);
}
else if (Objects.equals(action, "android.intent.action.PROCESS_TEXT")) {
String text = null;
try {
text = intent.getStringExtra(intent.EXTRA_PROCESS_TEXT);
} catch (Exception e) {
}
WritableMap files = new WritableNativeMap();
WritableMap file = new WritableNativeMap();
file.putString("contentUri", null);
file.putString("filePath", null);
file.putString("fileName", null);
file.putString("extension", null);
file.putString("weblink", null);
file.putString("text", text);
files.putMap("0", file);
promise.resolve(files);
}else{
promise.reject("error","Invalid file type.");
}
}catch (Exception e){
promise.reject("error",e.toString());
}
};
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public WritableMap getMediaUris(Intent intent, Context context){
if (intent == null) return null;
String subject = null;
try{
subject = intent.getStringExtra(Intent.EXTRA_SUBJECT);
}catch (Exception ignored){ }
WritableMap files = new WritableNativeMap();
if(Objects.equals(intent.getAction(), Intent.ACTION_SEND)){
WritableMap file = new WritableNativeMap();
Uri contentUri = (Uri) intent.getParcelableExtra(Intent.EXTRA_STREAM);
if(contentUri == null) return null;
String filePath = FileDirectory.INSTANCE.getAbsolutePath(context, contentUri);
ContentResolver contentResolver = context.getContentResolver();
file.putString("mimeType", contentResolver.getType(contentUri));
Cursor queryResult = contentResolver.query(contentUri, null, null, null, null);
queryResult.moveToFirst();
file.putString("fileName", queryResult.getString(queryResult.getColumnIndex(OpenableColumns.DISPLAY_NAME)));
file.putString("filePath", filePath);
file.putString("contentUri",contentUri.toString());
file.putString("text",null);
file.putString("weblink", null);
file.putString("subject", subject);
files.putMap("0",file);
}else if(Objects.equals(intent.getAction(), Intent.ACTION_SEND_MULTIPLE)) {
ArrayList<Uri> contentUris = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM);
if (contentUris != null) {
int index = 0;
for (Uri uri : contentUris) {
WritableMap file = new WritableNativeMap();
ContentResolver contentResolver = context.getContentResolver();
String filePath = FileDirectory.INSTANCE.getAbsolutePath(context, uri);
// Based on https://developer.android.com/training/secure-file-sharing/retrieve-info
file.putString("mimeType", contentResolver.getType(uri));
Cursor queryResult = contentResolver.query(uri, null, null, null, null);
queryResult.moveToFirst();
file.putString("fileName", queryResult.getString(queryResult.getColumnIndex(OpenableColumns.DISPLAY_NAME)));
file.putString("filePath", filePath);
file.putString("contentUri",uri.toString());
file.putString("text",null);
file.putString("weblink", null);
file.putString("subject", subject);
files.putMap(Integer.toString(index),file);
index++;
}
}
}
return files;
}
private String getMediaType(String url){
String mimeType = URLConnection.guessContentTypeFromName(url);
return mimeType;
}
public void clearFileNames(Intent intent){
String type = intent.getType();
if(type == null) return;
if (type.startsWith("text")) {
intent.removeExtra(Intent.EXTRA_TEXT);
} else if (type.startsWith("image") || type.startsWith("video") || type.startsWith("application")) {
intent.removeExtra(Intent.EXTRA_STREAM);
}
}
public String getFileName(String file){
return file.substring(file.lastIndexOf('/') + 1);
}
public String getExtension(String file){
return file.substring(file.lastIndexOf('.') + 1);
}
}
================================================
FILE: android/src/main/java/com/reactnativereceivesharingintent/ReceiveSharingIntentModule.java
================================================
package com.reactnativereceivesharingintent;
import android.app.Activity;
import android.app.Application;
import android.content.Intent;
import android.os.Build;
import androidx.annotation.RequiresApi;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
public class ReceiveSharingIntentModule extends ReactContextBaseJavaModule {
public final String Log_Tag = "ReceiveSharingIntent";
private final ReactApplicationContext reactContext;
private ReceiveSharingIntentHelper receiveSharingIntentHelper;
public ReceiveSharingIntentModule(ReactApplicationContext reactContext) {
super(reactContext);
this.reactContext = reactContext;
Application applicationContext = (Application) reactContext.getApplicationContext();
receiveSharingIntentHelper = new ReceiveSharingIntentHelper(applicationContext);
}
protected void onNewIntent(Intent intent) {
Activity mActivity = getCurrentActivity();
if(mActivity == null) { return; }
mActivity.setIntent(intent);
}
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
@ReactMethod
public void getFileNames(Promise promise){
Activity mActivity = getCurrentActivity();
if(mActivity == null) { return; }
Intent intent = mActivity.getIntent();
receiveSharingIntentHelper.sendFileNames(reactContext, intent, promise);
mActivity.setIntent(null);
}
@ReactMethod
public void clearFileNames(){
Activity mActivity = getCurrentActivity();
if(mActivity == null) { return; }
Intent intent = mActivity.getIntent();
receiveSharingIntentHelper.clearFileNames(intent);
}
@Override
public String getName() {
return "ReceiveSharingIntent";
}
}
================================================
FILE: android/src/main/java/com/reactnativereceivesharingintent/ReceiveSharingIntentPackage.kt
================================================
package com.reactnativereceivesharingintent
import com.facebook.react.ReactPackage
import com.facebook.react.bridge.NativeModule
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.uimanager.ViewManager
class ReceiveSharingIntentPackage : ReactPackage {
override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
return listOf(ReceiveSharingIntentModule(reactContext))
}
override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
return emptyList()
}
}
================================================
FILE: babel.config.js
================================================
module.exports = {
presets: ['module:metro-react-native-babel-preset'],
};
================================================
FILE: docs/.gitignore
================================================
# Dependencies
/node_modules
# Production
/build
# Generated files
.docusaurus
.cache-loader
# Misc
.DS_Store
.env.local
.env.development.local
.env.test.local
.env.production.local
npm-debug.log*
yarn-debug.log*
yarn-error.log*
================================================
FILE: docs/README.md
================================================
# Website
This website is built using [Docusaurus 2](https://docusaurus.io/), a modern static website generator.
## Installation
```console
yarn install
```
## Local Development
```console
yarn start
```
This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
## Build
```console
yarn build
```
This command generates static content into the `build` directory and can be served using any static contents hosting service.
## Deployment
```console
GIT_USER=<Your GitHub username> USE_SSH=true yarn deploy
```
If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.
================================================
FILE: docs/babel.config.js
================================================
module.exports = {
presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
};
================================================
FILE: docs/docs/android.md
================================================
---
sidebar_position: 2
---
# Android
` <Project_folder>/android/app/src/main/manifest.xml `
```xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example">
....
<!--TODO Add this Line -->
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<application .... >
<activity
....
android:launchMode="singleTask"> <!--TODO IMPORTANT.set launchMode -> singleTask Recommended -->
.....
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<!--TODO: Add this filter, if you want support opening urls into your app-->
<data
android:scheme="https"
android:host="example.com"
android:pathPrefix="/invite"/>
</intent-filter>
<!--TODO: Add this filter, if you want to support sharing text into your app-->
<intent-filter>
<action android:name="android.intent.action.SEND" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="text/*" />
</intent-filter>
<!--TODO: Add this filter, if you want to support sharing images into your app-->
<intent-filter>
<action android:name="android.intent.action.SEND" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="image/*" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.SEND_MULTIPLE" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="image/*" />
</intent-filter>
<!--TODO: Add this filter, if you want to support sharing videos into your app-->
<intent-filter>
<action android:name="android.intent.action.SEND" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="video/*" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.SEND_MULTIPLE" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="video/*" />
</intent-filter>
<!--TODO: Add this filter, if you want to support sharing any type of files-->
<intent-filter>
<action android:name="android.intent.action.SEND" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="*/*" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.SEND_MULTIPLE" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="*/*" />
</intent-filter>
.....
</activity>
</application>
</manifest>
```
- On MainActivity on your react-native app
` <Project_folder>/android/app/src/main/java/com/YOUR_APP/MainActivity.java` :
```java
// on top of your file
import android.content.Intent;
...
public class MainActivity extends ReactActivity {
...
// on your MainActivity Class body
@Override
public void onNewIntent(Intent intent) {
super.onNewIntent(intent);
setIntent(intent);
}
...
}
```
================================================
FILE: docs/docs/author.md
================================================
---
sidebar_position: 6
---
# Author
[Ajith A B](https://www.linkedin.com/in/ajith-a-b-a61303197)
### licenses
MIT
================================================
FILE: docs/docs/demo.md
================================================
---
sidebar_position: 4
---
# Demo
| Android | Ios |
| :---: | :---: |
| <img height="500" src="https://raw.githubusercontent.com/ajith-ab/react-native-receive-sharing-intent/master/doc/android.gif" />| <img height="500" src="https://raw.githubusercontent.com/ajith-ab/react-native-receive-sharing-intent/master/doc/ios.gif" /> |
================================================
FILE: docs/docs/donate.md
================================================
---
sidebar_position: 5
---
# Donate
<p><a href="https://www.paypal.me/ajithab" rel="nofollow"><img style={{ height: 100 }} src={'https://raw.githubusercontent.com/stefan-niedermann/paypal-donate-button/master/paypal-donate-button.png'} /></a></p>
================================================
FILE: docs/docs/intro.md
================================================
---
sidebar_position: 1
---
# Installation
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
<Tabs
defaultValue="npm"
values={[
{ label: 'npm', value: 'npm', },
{ label: 'yarn', value: 'yarn', },
]
}>
<TabItem value="npm">
```bash
$ npm install react-native-receive-sharing-intent --save
```
</TabItem>
<TabItem value="yarn">
```bash
$ yarn add react-native-receive-sharing-intent
```
</TabItem>
</Tabs>
## React Native version < 0.60.0
```shell
$ npx react-native link react-native-receive-sharing-intent
```
Note: `Ios and Android on Debbuging time not working at sometimes while App is Closed`
## Usage
```javascript
import ReceiveSharingIntent from 'react-native-receive-sharing-intent';
// To get All Recived Urls
ReceiveSharingIntent.getReceivedFiles(files => {
// files returns as JSON Array example
//[{ filePath: null, text: null, weblink: null, mimeType: null, contentUri: null, fileName: null, extension: null }]
},
(error) =>{
console.log(error);
},
'ShareMedia' // share url protocol (must be unique to your app, suggest using your apple bundle id)
);
// To clear Intents
ReceiveSharingIntent.clearReceivedFiles();
```
================================================
FILE: docs/docs/ios.md
================================================
---
sidebar_position: 3
---
# IOS
`<project_folder>/ios/<project_name>/info.plist`
```xml
<plist version="1.0">
<dict>
.....
<key>CFBundleURLTypes</key>
<array>
<dict>
<key>CFBundleTypeRole</key>
<string>Editor</string>
<key>CFBundleURLSchemes</key>
<array>
<string>ShareMedia</string> <!-- share url protocol (must be unique to your app, suggest using your apple bundle id) -->
</array>
</dict>
<dict/>
</array>
<key>NSPhotoLibraryUsageDescription</key>
<string>
To upload photos, please allow permission to access your photo library.
</string>
....
</dict>
</plist>
```
`<project_folder>/ios/<project_name>/AppDelegate.m`
```objectivec
....
#import <React/RCTLinkingManager.h> // Add this Line in Header of file
....
@implementation AppDelegate
...
- (BOOL)application:(UIApplication *)application
openURL:(NSURL *)url
options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options
{
return [RCTLinkingManager application:application openURL:url options:options];
}
@end
```
`<project_folder>/ios/<your project name>/<your project name>.entitlements`
```xml
....
<!--TODO: Add this tag, if you want support opening urls into your app-->
<key>com.apple.developer.associated-domains</key>
<array>
<string>applinks:example.com</string>
</array>
....
```
## Create Share Extension
- Using xcode, go to File/New/Target and Choose "Share Extension"
- Give it a name you want to show on while Sharing i.e. i Choose "Example Share"
:::info
Please Change Share Extension Target deployment version to Same as Main Project Target deployment version
:::
`<project_folder>/ios/<Your Share Extension Name>/info.plist`
```xml
<plist version="1.0">
<dict>
...
<key>NSExtension</key>
<dict>
<key>NSExtensionAttributes</key>
<dict>
<key>PHSupportedMediaTypes</key>
<array>
<!--TODO: Add this flag, if you want to support sharing video into your app-->
<string>Video</string>
<!--TODO: Add this flag, if you want to support sharing images into your app-->
<string>Image</string>
</array>
<key>NSExtensionActivationRule</key>
<dict>
<!--TODO: Add this flag, if you want to support sharing text into your app-->
<key>NSExtensionActivationSupportsText</key>
<true/>
<!--TODO: Add this tag, if you want to support sharing urls into your app-->
<key>NSExtensionActivationSupportsWebURLWithMaxCount</key>
<integer>1</integer>
<!--TODO: Add this flag, if you want to support sharing images into your app-->
<key>NSExtensionActivationSupportsImageWithMaxCount</key>
<integer>100</integer>
<!--TODO: Add this flag, if you want to support sharing video into your app-->
<key>NSExtensionActivationSupportsMovieWithMaxCount</key>
<integer>100</integer>
<!--TODO: Add this flag, if you want to support sharing other files into your app-->
<!--Change the integer to however many files you want to be able to share at a time-->
<key>NSExtensionActivationSupportsFileWithMaxCount</key>
<integer>100</integer>
</dict>
</dict>
<key>NSExtensionMainStoryboard</key>
<string>MainInterface</string>
<key>NSExtensionPointIdentifier</key>
<string>com.apple.share-services</string>
</dict>
</dict>
</plist>
```
`<project_folder>/ios/<Your Share Extension Name>/ShareViewController.swift`
- <b> Note: Important </b> change the `hostAppBundleIdentifier` value to your main host app bundle identifier (example in my case: `com.rnreceivesharingintent` ) in this `ShareViewController.swift`
```javascript
import UIKit
import Social
import MobileCoreServices
import Photos
class ShareViewController: SLComposeServiceViewController {
// TODO: IMPORTANT: This should be your host app bundle identifier
let hostAppBundleIdentifier = "com.rnreceivesharingintent"
let shareProtocol = "ShareMedia" //share url protocol (must be unique to your app, suggest using your apple bundle id, ie: `hostAppBundleIdentifier`)
let sharedKey = "ShareKey"
var sharedMedia: [SharedMediaFile] = []
var sharedText: [String] = []
let imageContentType = kUTTypeImage as String
let videoContentType = kUTTypeMovie as String
let textContentType = kUTTypeText as String
let urlContentType = kUTTypeURL as String
let fileURLType = kUTTypeFileURL as String;
override func isContentValid() -> Bool {
return true
}
override func viewDidLoad() {
super.viewDidLoad();
}
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
if let content = extensionContext!.inputItems[0] as? NSExtensionItem {
if let contents = content.attachments {
for (index, attachment) in (contents).enumerated() {
if attachment.hasItemConformingToTypeIdentifier(imageContentType) {
handleImages(content: content, attachment: attachment, index: index)
} else if attachment.hasItemConformingToTypeIdentifier(textContentType) {
handleText(content: content, attachment: attachment, index: index)
} else if attachment.hasItemConformingToTypeIdentifier(fileURLType) {
handleFiles(content: content, attachment: attachment, index: index)
} else if attachment.hasItemConformingToTypeIdentifier(urlContentType) {
handleUrl(content: content, attachment: attachment, index: index)
} else if attachment.hasItemConformingToTypeIdentifier(videoContentType) {
handleVideos(content: content, attachment: attachment, index: index)
}
}
}
}
}
override func didSelectPost() {
print("didSelectPost");
}
override func configurationItems() -> [Any]! {
// To add configuration options via table cells at the bottom of the sheet, return an array of SLComposeSheetConfigurationItem here.
return []
}
private func handleText (content: NSExtensionItem, attachment: NSItemProvider, index: Int) {
attachment.loadItem(forTypeIdentifier: textContentType, options: nil) { [weak self] data, error in
if error == nil, let item = data as? String, let this = self {
this.sharedText.append(item)
// If this is the last item, save imagesData in userDefaults and redirect to host app
if index == (content.attachments?.count)! - 1 {
let userDefaults = UserDefaults(suiteName: "group.\(this.hostAppBundleIdentifier)")
userDefaults?.set(this.sharedText, forKey: this.sharedKey)
userDefaults?.synchronize()
this.redirectToHostApp(type: .text)
}
} else {
self?.dismissWithError()
}
}
}
private func handleUrl (content: NSExtensionItem, attachment: NSItemProvider, index: Int) {
attachment.loadItem(forTypeIdentifier: urlContentType, options: nil) { [weak self] data, error in
if error == nil, let item = data as? URL, let this = self {
this.sharedText.append(item.absoluteString)
// If this is the last item, save imagesData in userDefaults and redirect to host app
if index == (content.attachments?.count)! - 1 {
let userDefaults = UserDefaults(suiteName: "group.\(this.hostAppBundleIdentifier)")
userDefaults?.set(this.sharedText, forKey: this.sharedKey)
userDefaults?.synchronize()
this.redirectToHostApp(type: .text)
}
} else {
self?.dismissWithError()
}
}
}
private func handleImages (content: NSExtensionItem, attachment: NSItemProvider, index: Int) {
attachment.loadItem(forTypeIdentifier: imageContentType, options: nil) { [weak self] data, error in
if error == nil, let url = data as? URL, let this = self {
// this.redirectToHostApp(type: .media)
// Always copy
let fileExtension = this.getExtension(from: url, type: .video)
let newName = UUID().uuidString
let newPath = FileManager.default
.containerURL(forSecurityApplicationGroupIdentifier: "group.\(this.hostAppBundleIdentifier)")!
.appendingPathComponent("\(newName).\(fileExtension)")
let copied = this.copyFile(at: url, to: newPath)
if(copied) {
this.sharedMedia.append(SharedMediaFile(path: newPath.absoluteString, thumbnail: nil, duration: nil, type: .image))
}
// If this is the last item, save imagesData in userDefaults and redirect to host app
if index == (content.attachments?.count)! - 1 {
let userDefaults = UserDefaults(suiteName: "group.\(this.hostAppBundleIdentifier)")
userDefaults?.set(this.toData(data: this.sharedMedia), forKey: this.sharedKey)
userDefaults?.synchronize()
this.redirectToHostApp(type: .media)
}
} else {
self?.dismissWithError()
}
}
}
private func handleVideos (content: NSExtensionItem, attachment: NSItemProvider, index: Int) {
attachment.loadItem(forTypeIdentifier: videoContentType, options:nil) { [weak self] data, error in
if error == nil, let url = data as? URL, let this = self {
// Always copy
let fileExtension = this.getExtension(from: url, type: .video)
let newName = UUID().uuidString
let newPath = FileManager.default
.containerURL(forSecurityApplicationGroupIdentifier: "group.\(this.hostAppBundleIdentifier)")!
.appendingPathComponent("\(newName).\(fileExtension)")
let copied = this.copyFile(at: url, to: newPath)
if(copied) {
guard let sharedFile = this.getSharedMediaFile(forVideo: newPath) else {
return
}
this.sharedMedia.append(sharedFile)
}
// If this is the last item, save imagesData in userDefaults and redirect to host app
if index == (content.attachments?.count)! - 1 {
let userDefaults = UserDefaults(suiteName: "group.\(this.hostAppBundleIdentifier)")
userDefaults?.set(this.toData(data: this.sharedMedia), forKey: this.sharedKey)
userDefaults?.synchronize()
this.redirectToHostApp(type: .media)
}
} else {
self?.dismissWithError()
}
}
}
private func handleFiles (content: NSExtensionItem, attachment: NSItemProvider, index: Int) {
attachment.loadItem(forTypeIdentifier: fileURLType, options: nil) { [weak self] data, error in
if error == nil, let url = data as? URL, let this = self {
// Always copy
let newName = this.getFileName(from :url)
let newPath = FileManager.default
.containerURL(forSecurityApplicationGroupIdentifier: "group.\(this.hostAppBundleIdentifier)")!
.appendingPathComponent("\(newName)")
let copied = this.copyFile(at: url, to: newPath)
if (copied) {
this.sharedMedia.append(SharedMediaFile(path: newPath.absoluteString, thumbnail: nil, duration: nil, type: .file))
}
if index == (content.attachments?.count)! - 1 {
let userDefaults = UserDefaults(suiteName: "group.\(this.hostAppBundleIdentifier)")
userDefaults?.set(this.toData(data: this.sharedMedia), forKey: this.sharedKey)
userDefaults?.synchronize()
this.redirectToHostApp(type: .file)
}
} else {
self?.dismissWithError()
}
}
}
private func dismissWithError() {
print("[ERROR] Error loading data!")
let alert = UIAlertController(title: "Error", message: "Error loading data", preferredStyle: .alert)
let action = UIAlertAction(title: "Error", style: .cancel) { _ in
self.dismiss(animated: true, completion: nil)
}
alert.addAction(action)
present(alert, animated: true, completion: nil)
extensionContext!.completeRequest(returningItems: [], completionHandler: nil)
}
private func redirectToHostApp(type: RedirectType) {
let url = URL(string: "\(shareProtocol)://dataUrl=\(sharedKey)#\(type)")
var responder = self as UIResponder?
let selectorOpenURL = sel_registerName("openURL:")
while (responder != nil) {
if (responder?.responds(to: selectorOpenURL))! {
let _ = responder?.perform(selectorOpenURL, with: url)
}
responder = responder!.next
}
extensionContext!.completeRequest(returningItems: [], completionHandler: nil)
}
enum RedirectType {
case media
case text
case file
}
func getExtension(from url: URL, type: SharedMediaType) -> String {
let parts = url.lastPathComponent.components(separatedBy: ".")
var ex: String? = nil
if (parts.count > 1) {
ex = parts.last
}
if (ex == nil) {
switch type {
case .image:
ex = "PNG"
case .video:
ex = "MP4"
case .file:
ex = "TXT"
}
}
return ex ?? "Unknown"
}
func getFileName(from url: URL) -> String {
var name = url.lastPathComponent
if (name == "") {
name = UUID().uuidString + "." + getExtension(from: url, type: .file)
}
return name
}
func copyFile(at srcURL: URL, to dstURL: URL) -> Bool {
do {
if FileManager.default.fileExists(atPath: dstURL.path) {
try FileManager.default.removeItem(at: dstURL)
}
try FileManager.default.copyItem(at: srcURL, to: dstURL)
} catch (let error) {
print("Cannot copy item at \(srcURL) to \(dstURL): \(error)")
return false
}
return true
}
private func getSharedMediaFile(forVideo: URL) -> SharedMediaFile? {
let asset = AVAsset(url: forVideo)
let duration = (CMTimeGetSeconds(asset.duration) * 1000).rounded()
let thumbnailPath = getThumbnailPath(for: forVideo)
if FileManager.default.fileExists(atPath: thumbnailPath.path) {
return SharedMediaFile(path: forVideo.absoluteString, thumbnail: thumbnailPath.absoluteString, duration: duration, type: .video)
}
var saved = false
let assetImgGenerate = AVAssetImageGenerator(asset: asset)
assetImgGenerate.appliesPreferredTrackTransform = true
// let scale = UIScreen.main.scale
assetImgGenerate.maximumSize = CGSize(width: 360, height: 360)
do {
let img = try assetImgGenerate.copyCGImage(at: CMTimeMakeWithSeconds(600, preferredTimescale: Int32(1.0)), actualTime: nil)
try UIImage.pngData(UIImage(cgImage: img))()?.write(to: thumbnailPath)
saved = true
} catch {
saved = false
}
return saved ? SharedMediaFile(path: forVideo.absoluteString, thumbnail: thumbnailPath.absoluteString, duration: duration, type: .video) : nil
}
private func getThumbnailPath(for url: URL) -> URL {
let fileName = Data(url.lastPathComponent.utf8).base64EncodedString().replacingOccurrences(of: "==", with: "")
let path = FileManager.default
.containerURL(forSecurityApplicationGroupIdentifier: "group.\(hostAppBundleIdentifier)")!
.appendingPathComponent("\(fileName).jpg")
return path
}
class SharedMediaFile: Codable {
var path: String; // can be image, video or url path. It can also be text content
var thumbnail: String?; // video thumbnail
var duration: Double?; // video duration in milliseconds
var type: SharedMediaType;
init(path: String, thumbnail: String?, duration: Double?, type: SharedMediaType) {
self.path = path
self.thumbnail = thumbnail
self.duration = duration
self.type = type
}
// Debug method to print out SharedMediaFile details in the console
func toString() {
print("[SharedMediaFile] \n\tpath: \(self.path)\n\tthumbnail: \(self.thumbnail)\n\tduration: \(self.duration)\n\ttype: \(self.type)")
}
}
enum SharedMediaType: Int, Codable {
case image
case video
case file
}
func toData(data: [SharedMediaFile]) -> Data {
let encodedData = try? JSONEncoder().encode(data)
return encodedData!
}
}
extension Array {
subscript (safe index: UInt) -> Element? {
return Int(index) < count ? self[Int(index)] : nil
}
}
```
## Create App Group
- Go to the Capabilities tab and switch on the App Groups switch for both targets. Add a new group and name it group.YOUR_HOST_APP_BUNDLE_IDENTIFIER in my case group.com.rnreceivesharinginten
- App group name must be start with `group.`
1. Create a app group for main App
2. Create a app group for Share Extension
## Compiling issues and their fixes
- Error: App does not build after adding Share Extension?
Fix: Check Build Settings of your share extension and remove everything that tries to import Cocoapods from your main project. i.e. remove everything under Linking/Other Linker Flags
- You might need to disable bitcode for the extension target
- <a href="https://github.com/facebookarchive/react-native-fbsdk/issues/794" >ERROR RUNNING ON XCODE 12</a>
- <a href="https://khushwanttanwar.medium.com/xcode-12-compilation-errors-while-running-with-ios-14-simulators-5731c91326e9" >Xcode 12 Compilation Errors (While running with iOS 14 Simulators)</a>
================================================
FILE: docs/docusaurus.config.js
================================================
/** @type {import('@docusaurus/types').DocusaurusConfig} */
module.exports = {
title: 'React Native Receive Sharing Intent',
tagline: 'A React Native plugin that enables React Native apps to receive sharing photos, videos, text, urls or any other file types from another app.',
url: 'https://ajith-ab.github.io',
baseUrl: '/react-native-receive-sharing-intent/',
onBrokenLinks: 'throw',
onBrokenMarkdownLinks: 'warn',
favicon: 'img/favicon.ico',
organizationName: 'ajith-ab', // Usually your GitHub org/user name.
projectName: 'react-native-receive-sharing-intent', // Usually your repo name.
themeConfig: {
navbar: {
title: 'React Native Receive Sharing Intent',
logo: {
alt: 'My Site Logo',
src: 'img/RN.png',
},
items: [
{
type: 'doc',
docId: 'intro',
position: 'left',
label: 'Installation',
},
{
type: 'doc',
docId: 'demo',
position: 'left',
label: 'Demo',
},
{
href: 'https://ajith-ab.github.io/react-native-receive-sharing-intent',
label: 'GitHub',
position: 'right',
},
],
},
footer: {
style: 'dark',
links: [
{
title: 'Docs',
items: [
{
label: 'Installation',
to: '/docs/intro',
},
],
},
{
title: 'Community',
items: [
{
label: 'Stack Overflow',
href: 'https://stackoverflow.com/questions/tagged/React-Native-Receive-Sharing-Intent',
}
],
},
],
copyright: `Copyright © ${new Date().getFullYear()} React Native Receive Sharing Intent.`
},
},
presets: [
[
'@docusaurus/preset-classic',
{
docs: {
sidebarPath: require.resolve('./sidebars.js'),
// Please change this to your repo.
editUrl:
'https://ajith-ab.github.io/react-native-receive-sharing-intent/docs/',
},
theme: {
customCss: require.resolve('./src/css/custom.css'),
},
},
],
],
};
================================================
FILE: docs/package.json
================================================
{
"name": "react-native-receive-sharing-intent",
"version": "0.0.0",
"private": true,
"scripts": {
"docusaurus": "docusaurus",
"start": "docusaurus start",
"build": "docusaurus build",
"swizzle": "docusaurus swizzle",
"deploy": "docusaurus deploy",
"clear": "docusaurus clear",
"serve": "docusaurus serve",
"write-translations": "docusaurus write-translations",
"write-heading-ids": "docusaurus write-heading-ids"
},
"dependencies": {
"@docusaurus/core": "2.0.0-alpha.74",
"@docusaurus/preset-classic": "2.0.0-alpha.74",
"@mdx-js/react": "^1.6.21",
"clsx": "^1.1.1",
"gh-pages": "^3.1.0",
"react": "^17.0.1",
"react-adsense": "^0.1.0",
"react-dom": "^17.0.1"
},
"browserslist": {
"production": [
">0.5%",
"not dead",
"not op_mini all"
],
"development": [
"last 1 chrome version",
"last 1 firefox version",
"last 1 safari version"
]
},
"devDependencies": {
"@docusaurus/module-type-aliases": "^2.0.0-alpha.74",
"@tsconfig/docusaurus": "^1.0.2",
"@types/react": "^17.0.4",
"@types/react-helmet": "^6.1.1",
"@types/react-router-dom": "^5.1.7",
"typescript": "^4.2.4"
}
}
================================================
FILE: docs/sidebars.js
================================================
/**
* Creating a sidebar enables you to:
- create an ordered group of docs
- render a sidebar for each doc of that group
- provide next/previous navigation
The sidebars can be generated from the filesystem, or explicitly defined here.
Create as many sidebars as you want.
*/
module.exports = {
// By default, Docusaurus generates a sidebar from the docs folder structure
tutorialSidebar: [{type: 'autogenerated', dirName: '.'}],
// But you can create a sidebar manually
/*
tutorialSidebar: [
{
type: 'category',
label: 'Tutorial',
items: ['hello'],
},
],
*/
};
================================================
FILE: docs/src/components/HomepageFeatures.js
================================================
import React from 'react';
import clsx from 'clsx';
import styles from './HomepageFeatures.module.css';
const FeatureList = [
{
title: 'Easy to Use',
Svg: require('../../static/img/undraw_docusaurus_mountain.svg').default,
description: (
<>
Docusaurus was designed from the ground up to be easily installed and
used to get your website up and running quickly.
</>
),
},
{
title: 'Focus on What Matters',
Svg: require('../../static/img/undraw_docusaurus_tree.svg').default,
description: (
<>
Docusaurus lets you focus on your docs, and we'll do the chores. Go
ahead and move your docs into the <code>docs</code> directory.
</>
),
},
{
title: 'Powered by React',
Svg: require('../../static/img/undraw_docusaurus_react.svg').default,
description: (
<>
Extend or customize your website layout by reusing React. Docusaurus can
be extended while reusing the same header and footer.
</>
),
},
];
function Feature({Svg, title, description}) {
return (
<div className={clsx('col col--4')}>
<div className="text--center">
<Svg className={styles.featureSvg} alt={title} />
</div>
<div className="text--center padding-horiz--md">
<h3>{title}</h3>
<p>{description}</p>
</div>
</div>
);
}
export default function HomepageFeatures() {
return (
<section className={styles.features}>
<div className="container">
<div className="row">
{FeatureList.map((props, idx) => (
<Feature key={idx} {...props} />
))}
</div>
</div>
</section>
);
}
================================================
FILE: docs/src/components/HomepageFeatures.module.css
================================================
/* stylelint-disable docusaurus/copyright-header */
.features {
display: flex;
align-items: center;
padding: 2rem 0;
width: 100%;
}
.featureSvg {
height: 200px;
width: 200px;
}
================================================
FILE: docs/src/css/custom.css
================================================
/* stylelint-disable docusaurus/copyright-header */
/**
* Any CSS included here will be global. The classic template
* bundles Infima by default. Infima is a CSS framework designed to
* work well for content-centric websites.
*/
/* You can override the default Infima variables here. */
:root {
--ifm-color-primary: #0b4137;
--ifm-color-primary-dark: rgb(33, 175, 144);
--ifm-color-primary-darker: rgb(31, 165, 136);
--ifm-color-primary-darkest: rgb(26, 136, 112);
--ifm-color-primary-light: rgb(70, 203, 174);
--ifm-color-primary-lighter: rgb(102, 212, 189);
--ifm-color-primary-lightest: rgb(146, 224, 208);
--ifm-code-font-size: 95%;
}
.docusaurus-highlight-code-line {
background-color: rgb(72, 77, 91);
display: block;
margin: 0 calc(-1 * var(--ifm-pre-padding));
padding: 0 var(--ifm-pre-padding);
}
================================================
FILE: docs/src/pages/index.js
================================================
import React, { useEffect } from 'react';
import clsx from 'clsx';
import Layout from '@theme/Layout';
import Link from '@docusaurus/Link';
import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
import styles from './index.module.css';
import AdSense from 'react-adsense';
function HomepageHeader() {
const {siteConfig} = useDocusaurusContext();
return (
<header className={clsx('hero hero--primary', styles.heroBanner)}>
<div className="container">
<h1 className="hero__title">{siteConfig.title}</h1>
<p className="hero__subtitle">{siteConfig.tagline}</p>
<div className={styles.buttons}>
<Link
className="button button--secondary button--lg"
to="/docs/intro">
Get Started
</Link>
</div>
</div>
</header>
);
}
export default function Home() {
const {siteConfig} = useDocusaurusContext();
useEffect(()=>{
const installGoogleAds = () => {
const elem = document.createElement("script");
elem.src =
"//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js";
elem.async = true;
elem.defer = true;
document.body.insertBefore(elem, document.body.firstChild);
};
installGoogleAds();
}, [])
return (
<Layout
title={`Hello from ${siteConfig.title}`}
description="Description will go into a meta tag in <head />">
<HomepageHeader />
<main>
<AdSense.Google
client='ca-pub-6959248551010269'
slot='7895558233'
style={{ display: 'block' }}
format='auto'
responsive='true'
/>
</main>
</Layout>
);
}
================================================
FILE: docs/src/pages/index.module.css
================================================
/* stylelint-disable docusaurus/copyright-header */
/**
* CSS files with the .module.css suffix will be treated as CSS modules
* and scoped locally.
*/
.heroBanner {
padding: 4rem 0;
text-align: center;
position: relative;
overflow: hidden;
}
@media screen and (max-width: 966px) {
.heroBanner {
padding: 2rem;
}
}
.buttons {
display: flex;
align-items: center;
justify-content: center;
}
================================================
FILE: docs/src/pages/markdown-page.md
================================================
---
title: Markdown page example
---
# Markdown page example
You don't need React to write simple standalone pages.
================================================
FILE: docs/src/theme/Footer/index.tsx
================================================
/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
import React from 'react';
import clsx from 'clsx';
import Link from '@docusaurus/Link';
import {FooterLinkItem, useThemeConfig} from '@docusaurus/theme-common';
import useBaseUrl from '@docusaurus/useBaseUrl';
import styles from './styles.module.css';
import ThemedImage, {Props as ThemedImageProps} from '@theme/ThemedImage';
function FooterLink({
to,
href,
label,
prependBaseUrlToHref,
...props
}: FooterLinkItem) {
const toUrl = useBaseUrl(to);
const normalizedHref = useBaseUrl(href, {forcePrependBaseUrl: true});
return (
<Link
className="footer__link-item"
{...(href
? {
href: prependBaseUrlToHref ? normalizedHref : href,
}
: {
to: toUrl,
})}
{...props}>
{label}
</Link>
);
}
const FooterLogo = ({
sources,
alt,
}: Pick<ThemedImageProps, 'sources' | 'alt'>) => (
<ThemedImage className="footer__logo" alt={alt} sources={sources} />
);
function Footer(): JSX.Element | null {
const {footer} = useThemeConfig();
const {copyright, links = [], logo = {}} = footer || {};
const sources = {
light: useBaseUrl(logo.src),
dark: useBaseUrl(logo.srcDark || logo.src),
};
if (!footer) {
return null;
}
return (
<footer
className={clsx('footer', {
'footer--dark': footer.style === 'dark',
})}>
<div className="container">
{links && links.length > 0 && (
<div className="row footer__links">
{links.map((linkItem, i) => (
<div key={i} className="col footer__col">
{linkItem.title != null ? (
<h4 className="footer__title">{linkItem.title}</h4>
) : null}
{linkItem.items != null &&
Array.isArray(linkItem.items) &&
linkItem.items.length > 0 ? (
<ul className="footer__items">
{linkItem.items.map((item, key) =>
item.html ? (
<li
key={key}
className="footer__item"
// Developer provided the HTML, so assume it's safe.
// eslint-disable-next-line react/no-danger
dangerouslySetInnerHTML={{
__html: item.html,
}}
/>
) : (
<li key={item.href || item.to} className="footer__item">
<FooterLink {...item} />
</li>
),
)}
</ul>
) : null}
</div>
))}
</div>
)}
{(logo || copyright) && (
<div className="footer__bottom text--center">
{logo && (logo.src || logo.srcDark) && (
<div className="margin-bottom--sm">
{logo.href ? (
<Link href={logo.href} className={styles.footerLogoLink}>
<FooterLogo alt={logo.alt} sources={sources} />
</Link>
) : (
<FooterLogo alt={logo.alt} sources={sources} />
)}
</div>
)}
{copyright ? (
<div
className="footer__copyright"
// Developer provided the HTML, so assume it's safe.
// eslint-disable-next-line react/no-danger
dangerouslySetInnerHTML={{
__html: copyright,
}}
/>
) : null}
</div>
)}
</div>
</footer>
);
}
export default Footer;
================================================
FILE: docs/src/theme/Footer/styles.module.css
================================================
/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
.footerLogoLink {
opacity: 0.5;
transition: opacity var(--ifm-transition-fast) var(--ifm-transition-timing-default);
}
.footerLogoLink:hover {
opacity: 1;
}
================================================
FILE: docs/static/.nojekyll
================================================
================================================
FILE: docs/tsconfig.json
================================================
{
"extends": "@tsconfig/docusaurus/tsconfig.json",
"include": ["src/"]
}
================================================
FILE: example/android/app/build.gradle
================================================
apply plugin: "com.android.application"
import com.android.build.OutputFile
/**
* The react.gradle file registers a task for each build variant (e.g. bundleDebugJsAndAssets
* and bundleReleaseJsAndAssets).
* These basically call `react-native bundle` with the correct arguments during the Android build
* cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the
* bundle directly from the development server. Below you can see all the possible configurations
* and their defaults. If you decide to add a configuration block, make sure to add it before the
* `apply from: "../../node_modules/react-native/react.gradle"` line.
*
* project.ext.react = [
* // the name of the generated asset file containing your JS bundle
* bundleAssetName: "index.android.bundle",
*
* // the entry file for bundle generation
* entryFile: "index.android.js",
*
* // https://reactnative.dev/docs/performance#enable-the-ram-format
* bundleCommand: "ram-bundle",
*
* // whether to bundle JS and assets in debug mode
* bundleInDebug: false,
*
* // whether to bundle JS and assets in release mode
* bundleInRelease: true,
*
* // whether to bundle JS and assets in another build variant (if configured).
* // See http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Build-Variants
* // The configuration property can be in the following formats
* // 'bundleIn${productFlavor}${buildType}'
* // 'bundleIn${buildType}'
* // bundleInFreeDebug: true,
* // bundleInPaidRelease: true,
* // bundleInBeta: true,
*
* // whether to disable dev mode in custom build variants (by default only disabled in release)
* // for ReceiveSharingIntentExample: to disable dev mode in the staging build type (if configured)
* devDisabledInStaging: true,
* // The configuration property can be in the following formats
* // 'devDisabledIn${productFlavor}${buildType}'
* // 'devDisabledIn${buildType}'
*
* // the root of your project, i.e. where "package.json" lives
* root: "../../",
*
* // where to put the JS bundle asset in debug mode
* jsBundleDirDebug: "$buildDir/intermediates/assets/debug",
*
* // where to put the JS bundle asset in release mode
* jsBundleDirRelease: "$buildDir/intermediates/assets/release",
*
* // where to put drawable resources / React Native assets, e.g. the ones you use via
* // require('./image.png')), in debug mode
* resourcesDirDebug: "$buildDir/intermediates/res/merged/debug",
*
* // where to put drawable resources / React Native assets, e.g. the ones you use via
* // require('./image.png')), in release mode
* resourcesDirRelease: "$buildDir/intermediates/res/merged/release",
*
* // by default the gradle tasks are skipped if none of the JS files or assets change; this means
* // that we don't look at files in android/ or ios/ to determine whether the tasks are up to
* // date; if you have any other folders that you want to ignore for performance reasons (gradle
* // indexes the entire tree), add them here. Alternatively, if you have JS files in android/
* // for ReceiveSharingIntentExample, you might want to remove it from here.
* inputExcludes: ["android/**", "ios/**"],
*
* // override which node gets called and with what additional arguments
* nodeExecutableAndArgs: ["node"],
*
* // supply additional arguments to the packager
* extraPackagerArgs: []
* ]
*/
project.ext.react = [
enableHermes: false, // clean and rebuild if changing
entryFile: "index.tsx",
]
apply from: "../../node_modules/react-native/react.gradle"
/**
* Set this to true to create two separate APKs instead of one:
* - An APK that only works on ARM devices
* - An APK that only works on x86 devices
* The advantage is the size of the APK is reduced by about 4MB.
* Upload all the APKs to the Play Store and people will download
* the correct one based on the CPU architecture of their device.
*/
def enableSeparateBuildPerCPUArchitecture = false
/**
* Run Proguard to shrink the Java bytecode in release builds.
*/
def enableProguardInReleaseBuilds = false
/**
* The preferred build flavor of JavaScriptCore.
*
* For ReceiveSharingIntentExample, to use the international variant, you can use:
* `def jscFlavor = 'org.webkit:android-jsc-intl:+'`
*
* The international variant includes ICU i18n library and necessary data
* allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
* give correct results when using with locales other than en-US. Note that
* this variant is about 6MiB larger per architecture than default.
*/
def jscFlavor = 'org.webkit:android-jsc:+'
/**
* Whether to enable the Hermes VM.
*
* This should be set on project.ext.react and mirrored here. If it is not set
* on project.ext.react, JavaScript will not be compiled to Hermes Bytecode
* and the benefits of using Hermes will therefore be sharply reduced.
*/
def enableHermes = project.ext.react.get("enableHermes", false);
android {
compileSdkVersion rootProject.ext.compileSdkVersion
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
defaultConfig {
applicationId "com.example.reactnativereceivesharingintent"
minSdkVersion rootProject.ext.minSdkVersion
targetSdkVersion rootProject.ext.targetSdkVersion
versionCode 1
versionName "1.0"
}
splits {
abi {
reset()
enable enableSeparateBuildPerCPUArchitecture
universalApk false // If true, also generate a universal APK
include "armeabi-v7a", "x86", "arm64-v8a", "x86_64"
}
}
signingConfigs {
debug {
storeFile file('debug.keystore')
storePassword 'android'
keyAlias 'androiddebugkey'
keyPassword 'android'
}
}
buildTypes {
debug {
signingConfig signingConfigs.debug
}
release {
// Caution! In production, you need to generate your own keystore file.
// see https://reactnative.dev/docs/signed-apk-android.
signingConfig signingConfigs.debug
minifyEnabled enableProguardInReleaseBuilds
proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
}
}
// applicationVariants are e.g. debug, release
applicationVariants.all { variant ->
variant.outputs.each { output ->
// For each separate APK per architecture, set a unique version code as described here:
// https://developer.android.com/studio/build/configure-apk-splits.html
def versionCodes = ["armeabi-v7a": 1, "x86": 2, "arm64-v8a": 3, "x86_64": 4]
def abi = output.getFilter(OutputFile.ABI)
if (abi != null) { // null for the universal-debug, universal-release variants
output.versionCodeOverride =
versionCodes.get(abi) * 1048576 + defaultConfig.versionCode
}
}
}
}
dependencies {
implementation fileTree(dir: "libs", include: ["*.jar"])
//noinspection GradleDynamicVersion
implementation "com.facebook.react:react-native:+" // From node_modules
implementation "androidx.swiperefreshlayout:swiperefreshlayout:1.0.0"
debugImplementation("com.facebook.flipper:flipper:${FLIPPER_VERSION}") {
exclude group:'com.facebook.fbjni'
}
debugImplementation("com.facebook.flipper:flipper-network-plugin:${FLIPPER_VERSION}") {
exclude group:'com.facebook.flipper'
exclude group:'com.squareup.okhttp3', module:'okhttp'
}
debugImplementation("com.facebook.flipper:flipper-fresco-plugin:${FLIPPER_VERSION}") {
exclude group:'com.facebook.flipper'
}
if (enableHermes) {
def hermesPath = "../../node_modules/hermes-engine/android/";
debugImplementation files(hermesPath + "hermes-debug.aar")
releaseImplementation files(hermesPath + "hermes-release.aar")
} else {
implementation jscFlavor
}
implementation project(':reactnativereceivesharingintent')
}
// Run this once to be able to run the application with BUCK
// puts all compile dependencies into folder libs for BUCK to use
task copyDownloadableDepsToLibs(type: Copy) {
from configurations.compile
into 'libs'
}
apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project)
================================================
FILE: example/android/app/proguard-rules.pro
================================================
# Add project specific ProGuard rules here.
# By default, the flags in this file are appended to flags specified
# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
# You can edit the include path and order by changing the proguardFiles
# directive in build.gradle.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# Add any project specific keep options here:
================================================
FILE: example/android/app/src/debug/AndroidManifest.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
<application android:usesCleartextTraffic="true" tools:targetApi="28" tools:ignore="GoogleAppIndexingWarning" />
</manifest>
================================================
FILE: example/android/app/src/debug/java/com/example/reactnativereceivesharingintent/ReactNativeFlipper.java
================================================
/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* <p>This source code is licensed under the MIT license found in the LICENSE file in the root
* directory of this source tree.
*/
package com.example.reactnativereceivesharingintent;
import android.content.Context;
import com.facebook.flipper.android.AndroidFlipperClient;
import com.facebook.flipper.android.utils.FlipperUtils;
import com.facebook.flipper.core.FlipperClient;
import com.facebook.flipper.plugins.crashreporter.CrashReporterPlugin;
import com.facebook.flipper.plugins.databases.DatabasesFlipperPlugin;
import com.facebook.flipper.plugins.fresco.FrescoFlipperPlugin;
import com.facebook.flipper.plugins.inspector.DescriptorMapping;
import com.facebook.flipper.plugins.inspector.InspectorFlipperPlugin;
import com.facebook.flipper.plugins.network.FlipperOkhttpInterceptor;
import com.facebook.flipper.plugins.network.NetworkFlipperPlugin;
import com.facebook.flipper.plugins.react.ReactFlipperPlugin;
import com.facebook.flipper.plugins.sharedpreferences.SharedPreferencesFlipperPlugin;
import com.facebook.react.ReactInstanceManager;
import com.facebook.react.bridge.ReactContext;
import com.facebook.react.modules.network.NetworkingModule;
import okhttp3.OkHttpClient;
public class ReactNativeFlipper {
public static void initializeFlipper(Context context, ReactInstanceManager reactInstanceManager) {
if (FlipperUtils.shouldEnableFlipper(context)) {
final FlipperClient client = AndroidFlipperClient.getInstance(context);
client.addPlugin(new InspectorFlipperPlugin(context, DescriptorMapping.withDefaults()));
client.addPlugin(new ReactFlipperPlugin());
client.addPlugin(new DatabasesFlipperPlugin(context));
client.addPlugin(new SharedPreferencesFlipperPlugin(context));
client.addPlugin(CrashReporterPlugin.getInstance());
NetworkFlipperPlugin networkFlipperPlugin = new NetworkFlipperPlugin();
NetworkingModule.setCustomClientBuilder(
new NetworkingModule.CustomClientBuilder() {
@Override
public void apply(OkHttpClient.Builder builder) {
builder.addNetworkInterceptor(new FlipperOkhttpInterceptor(networkFlipperPlugin));
}
});
client.addPlugin(networkFlipperPlugin);
client.start();
// Fresco Plugin needs to ensure that ImagePipelineFactory is initialized
// Hence we run if after all native modules have been initialized
ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
if (reactContext == null) {
reactInstanceManager.addReactInstanceEventListener(
new ReactInstanceManager.ReactInstanceEventListener() {
@Override
public void onReactContextInitialized(ReactContext reactContext) {
reactInstanceManager.removeReactInstanceEventListener(this);
reactContext.runOnNativeModulesQueueThread(
new Runnable() {
@Override
public void run() {
client.addPlugin(new FrescoFlipperPlugin());
}
});
}
});
} else {
client.addPlugin(new FrescoFlipperPlugin());
}
}
}
}
================================================
FILE: example/android/app/src/main/AndroidManifest.xml
================================================
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.reactnativereceivesharingintent">
<uses-permission android:name="android.permission.INTERNET" />
<application
android:name=".MainApplication"
android:label="@string/app_name"
android:icon="@mipmap/ic_launcher"
android:roundIcon="@mipmap/ic_launcher_round"
android:allowBackup="false"
android:theme="@style/AppTheme">
<activity
android:name=".MainActivity"
android:label="@string/app_name"
android:configChanges="keyboard|keyboardHidden|orientation|screenSize|uiMode"
android:launchMode="singleTask"
android:windowSoftInputMode="adjustResize">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
<!-- FOR ReceiveSharingIntent-->
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<!--TODO: Add this filter, if you want support opening urls into your app-->
<data
android:scheme="https"
android:host="example.com"
android:pathPrefix="/invite"/>
</intent-filter>
<!--TODO: Add this filter, if you want to support sharing text into your app-->
<intent-filter>
<action android:name="android.intent.action.SEND" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="text/*" />
</intent-filter>
<!--TODO: Add this filter, if you want to support sharing images into your app-->
<intent-filter>
<action android:name="android.intent.action.SEND" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="image/*" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.SEND_MULTIPLE" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="image/*" />
</intent-filter>
<!--TODO: Add this filter, if you want to support sharing videos into your app-->
<intent-filter>
<action android:name="android.intent.action.SEND" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="video/*" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.SEND_MULTIPLE" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="video/*" />
</intent-filter>
<!--TODO: Add this filter, if you want to support sharing any type of files-->
<intent-filter>
<action android:name="android.intent.action.SEND" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="*/*" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.SEND_MULTIPLE" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="*/*" />
</intent-filter>
</activity>
<activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
</application>
</manifest>
================================================
FILE: example/android/app/src/main/java/com/example/reactnativereceivesharingintent/MainActivity.java
================================================
package com.example.reactnativereceivesharingintent;
import android.content.Intent;
import android.util.Log;
import com.facebook.react.ReactActivity;
public class MainActivity extends ReactActivity {
/**
* Returns the name of the main component registered from JavaScript. This is used to schedule
* rendering of the component.
*/
@Override
public void onNewIntent(Intent intent) {
super.onNewIntent(intent);
setIntent(intent);
}
@Override
protected String getMainComponentName() {
return "ReceiveSharingIntentExample";
}
}
================================================
FILE: example/android/app/src/main/java/com/example/reactnativereceivesharingintent/MainApplication.java
================================================
package com.example.reactnativereceivesharingintent;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
import com.facebook.react.PackageList;
import com.facebook.react.ReactApplication;
import com.facebook.react.ReactNativeHost;
import com.facebook.react.ReactPackage;
import com.facebook.react.ReactInstanceManager;
import com.facebook.soloader.SoLoader;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
import com.reactnativereceivesharingintent.ReceiveSharingIntentPackage;
public class MainApplication extends Application implements ReactApplication {
private final ReactNativeHost mReactNativeHost =
new ReactNativeHost(this) {
@Override
public boolean getUseDeveloperSupport() {
return BuildConfig.DEBUG;
}
@Override
protected List<ReactPackage> getPackages() {
@SuppressWarnings("UnnecessaryLocalVariable")
List<ReactPackage> packages = new PackageList(this).getPackages();
// Packages that cannot be autolinked yet can be added manually here, for ReceiveSharingIntentExample:
// packages.add(new MyReactNativePackage());
packages.add(new ReceiveSharingIntentPackage());
return packages;
}
@Override
protected String getJSMainModuleName() {
return "index";
}
};
@Override
public ReactNativeHost getReactNativeHost() {
return mReactNativeHost;
}
@Override
public void onCreate() {
super.onCreate();
SoLoader.init(this, /* native exopackage */ false);
initializeFlipper(this, getReactNativeHost().getReactInstanceManager()); // Remove this line if you don't want Flipper enabled
}
/**
* Loads Flipper in React Native templates.
*
* @param context
*/
private static void initializeFlipper(Context context, ReactInstanceManager reactInstanceManager) {
if (BuildConfig.DEBUG) {
try {
/*
We use reflection here to pick up the class that initializes Flipper,
since Flipper library is not available in release mode
*/
Class<?> aClass = Class.forName("com.reactnativereceivesharingintentExample.ReactNativeFlipper");
aClass
.getMethod("initializeFlipper", Context.class, ReactInstanceManager.class)
.invoke(null, context, reactInstanceManager);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
================================================
FILE: example/android/app/src/main/res/values/strings.xml
================================================
<resources>
<string name="app_name">ReceiveSharingIntent Example</string>
</resources>
================================================
FILE: example/android/app/src/main/res/values/styles.xml
================================================
<resources>
<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
<!-- Customize your theme here. -->
<item name="android:textColor">#000000</item>
</style>
</resources>
================================================
FILE: example/android/build.gradle
================================================
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
ext {
buildToolsVersion = "29.0.2"
minSdkVersion = 16
compileSdkVersion = 29
targetSdkVersion = 29
}
repositories {
google()
jcenter()
}
dependencies {
classpath("com.android.tools.build:gradle:3.5.3")
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
allprojects {
repositories {
mavenLocal()
maven {
// All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
url("$rootDir/../node_modules/react-native/android")
}
maven {
// Android JSC is installed from npm
url("$rootDir/../node_modules/jsc-android/dist")
}
google()
jcenter()
maven { url 'https://www.jitpack.io' }
}
}
================================================
FILE: example/android/gradle/wrapper/gradle-wrapper.properties
================================================
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-6.2-all.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
================================================
FILE: example/android/gradle.properties
================================================
# Project-wide Gradle settings.
# IDE (e.g. Android Studio) users:
# Gradle settings configured through the IDE *will override*
# any settings specified in this file.
# For more details on how to configure your build environment visit
# http://www.gradle.org/docs/current/userguide/build_environment.html
# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
# org.gradle.parallel=true
android.useAndroidX=true
android.enableJetifier=true
FLIPPER_VERSION=0.54.0
================================================
FILE: example/android/gradlew
================================================
#!/usr/bin/env sh
#
# Copyright 2015 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin or MSYS, switch paths to Windows format before running java
if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=`expr $i + 1`
done
case $i in
0) set -- ;;
1) set -- "$args0" ;;
2) set -- "$args0" "$args1" ;;
3) set -- "$args0" "$args1" "$args2" ;;
4) set -- "$args0" "$args1" "$args2" "$args3" ;;
5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=`save "$@"`
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
exec "$JAVACMD" "$@"
================================================
FILE: example/android/gradlew.bat
================================================
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem http://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windows variants
if not "%OS%" == "Windows_NT" goto win9xME_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
================================================
FILE: example/android/settings.gradle
================================================
rootProject.name = 'ReceiveSharingIntentExample'
apply from: file("../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesSettingsGradle(settings)
include ':app'
include ':reactnativereceivesharingintent'
project(':reactnativereceivesharingintent').projectDir = new File(rootProject.projectDir, '../../android')
================================================
FILE: example/app.json
================================================
{
"name": "ReceiveSharingIntentExample",
"displayName": "ReceiveSharingIntent Example"
}
================================================
FILE: example/babel.config.js
================================================
const path = require('path');
const pak = require('../package.json');
module.exports = {
presets: ['module:metro-react-native-babel-preset'],
plugins: [
[
'module-resolver',
{
extensions: ['.tsx', '.ts', '.js', '.json'],
alias: {
[pak.name]: path.join(__dirname, '..', pak.source),
},
},
],
],
};
================================================
FILE: example/index.tsx
================================================
import { AppRegistry } from 'react-native';
import App from './src/App';
import { name as appName } from './app.json';
AppRegistry.registerComponent(appName, () => App);
================================================
FILE: example/ios/File.swift
================================================
//
// File.swift
// ReceiveSharingIntentExample
//
import Foundation
import Photos
================================================
FILE: example/ios/Podfile
================================================
require_relative '../node_modules/react-native/scripts/react_native_pods'
require_relative '../node_modules/@react-native-community/cli-platform-ios/native_modules'
platform :ios, '10.0'
target 'ReceiveSharingIntentExample' do
config = use_native_modules!
use_react_native!(:path => config["reactNativePath"])
pod 'react-native-receive-sharing-intent', :path => '../..'
# Enables Flipper.
#
# Note that if you have use_frameworks! enabled, Flipper will not work and
# you should disable these next few lines.
#use_flipper!
post_install do |installer|
flipper_post_install(installer)
installer.pods_project.build_configurations.each do |config|
config.build_settings["EXCLUDED_ARCHS[sdk=iphonesimulator*]"] = "arm64"
end
end
end
================================================
FILE: example/ios/Pods/DoubleConversion/LICENSE
================================================
Copyright 2006-2011, the V8 project authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: example/ios/Pods/DoubleConversion/README
================================================
http://code.google.com/p/double-conversion
This project (double-conversion) provides binary-decimal and decimal-binary
routines for IEEE doubles.
The library consists of efficient conversion routines that have been extracted
from the V8 JavaScript engine. The code has been refactored and improved so that
it can be used more easily in other projects.
There is extensive documentation in src/double-conversion.h. Other examples can
be found in test/cctest/test-conversions.cc.
Building
========
This library can be built with scons [0] or cmake [1].
The checked-in Makefile simply forwards to scons, and provides a
shortcut to run all tests:
make
make test
Scons
-----
The easiest way to install this library is to use `scons`. It builds
the static and shared library, and is set up to install those at the
correct locations:
scons install
Use the `DESTDIR` option to change the target directory:
scons DESTDIR=alternative_directory install
Cmake
-----
To use cmake run `cmake .` in the root directory. This overwrites the
existing Makefile.
Use `-DBUILD_SHARED_LIBS=ON` to enable the compilation of shared libraries.
Note that this disables static libraries. There is currently no way to
build both libraries at the same time with cmake.
Use `-DBUILD_TESTING=ON` to build the test executable.
cmake . -DBUILD_TESTING=ON
make
test/cctest/cctest --list | tr -d '<' | xargs test/cctest/cctest
[0]: http://www.scons.org
[1]: http://www.cmake.org
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/bignum-dtoa.cc
================================================
// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <math.h>
#include "bignum-dtoa.h"
#include "bignum.h"
#include "ieee.h"
namespace double_conversion {
static int NormalizedExponent(uint64_t significand, int exponent) {
ASSERT(significand != 0);
while ((significand & Double::kHiddenBit) == 0) {
significand = significand << 1;
exponent = exponent - 1;
}
return exponent;
}
// Forward declarations:
// Returns an estimation of k such that 10^(k-1) <= v < 10^k.
static int EstimatePower(int exponent);
// Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
// and denominator.
static void InitialScaledStartValues(uint64_t significand,
int exponent,
bool lower_boundary_is_closer,
int estimated_power,
bool need_boundary_deltas,
Bignum* numerator,
Bignum* denominator,
Bignum* delta_minus,
Bignum* delta_plus);
// Multiplies numerator/denominator so that its values lies in the range 1-10.
// Returns decimal_point s.t.
// v = numerator'/denominator' * 10^(decimal_point-1)
// where numerator' and denominator' are the values of numerator and
// denominator after the call to this function.
static void FixupMultiply10(int estimated_power, bool is_even,
int* decimal_point,
Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus);
// Generates digits from the left to the right and stops when the generated
// digits yield the shortest decimal representation of v.
static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus,
bool is_even,
Vector<char> buffer, int* length);
// Generates 'requested_digits' after the decimal point.
static void BignumToFixed(int requested_digits, int* decimal_point,
Bignum* numerator, Bignum* denominator,
Vector<char>(buffer), int* length);
// Generates 'count' digits of numerator/denominator.
// Once 'count' digits have been produced rounds the result depending on the
// remainder (remainders of exactly .5 round upwards). Might update the
// decimal_point when rounding up (for example for 0.9999).
static void GenerateCountedDigits(int count, int* decimal_point,
Bignum* numerator, Bignum* denominator,
Vector<char>(buffer), int* length);
void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
Vector<char> buffer, int* length, int* decimal_point) {
ASSERT(v > 0);
ASSERT(!Double(v).IsSpecial());
uint64_t significand;
int exponent;
bool lower_boundary_is_closer;
if (mode == BIGNUM_DTOA_SHORTEST_SINGLE) {
float f = static_cast<float>(v);
ASSERT(f == v);
significand = Single(f).Significand();
exponent = Single(f).Exponent();
lower_boundary_is_closer = Single(f).LowerBoundaryIsCloser();
} else {
significand = Double(v).Significand();
exponent = Double(v).Exponent();
lower_boundary_is_closer = Double(v).LowerBoundaryIsCloser();
}
bool need_boundary_deltas =
(mode == BIGNUM_DTOA_SHORTEST || mode == BIGNUM_DTOA_SHORTEST_SINGLE);
bool is_even = (significand & 1) == 0;
int normalized_exponent = NormalizedExponent(significand, exponent);
// estimated_power might be too low by 1.
int estimated_power = EstimatePower(normalized_exponent);
// Shortcut for Fixed.
// The requested digits correspond to the digits after the point. If the
// number is much too small, then there is no need in trying to get any
// digits.
if (mode == BIGNUM_DTOA_FIXED && -estimated_power - 1 > requested_digits) {
buffer[0] = '\0';
*length = 0;
// Set decimal-point to -requested_digits. This is what Gay does.
// Note that it should not have any effect anyways since the string is
// empty.
*decimal_point = -requested_digits;
return;
}
Bignum numerator;
Bignum denominator;
Bignum delta_minus;
Bignum delta_plus;
// Make sure the bignum can grow large enough. The smallest double equals
// 4e-324. In this case the denominator needs fewer than 324*4 binary digits.
// The maximum double is 1.7976931348623157e308 which needs fewer than
// 308*4 binary digits.
ASSERT(Bignum::kMaxSignificantBits >= 324*4);
InitialScaledStartValues(significand, exponent, lower_boundary_is_closer,
estimated_power, need_boundary_deltas,
&numerator, &denominator,
&delta_minus, &delta_plus);
// We now have v = (numerator / denominator) * 10^estimated_power.
FixupMultiply10(estimated_power, is_even, decimal_point,
&numerator, &denominator,
&delta_minus, &delta_plus);
// We now have v = (numerator / denominator) * 10^(decimal_point-1), and
// 1 <= (numerator + delta_plus) / denominator < 10
switch (mode) {
case BIGNUM_DTOA_SHORTEST:
case BIGNUM_DTOA_SHORTEST_SINGLE:
GenerateShortestDigits(&numerator, &denominator,
&delta_minus, &delta_plus,
is_even, buffer, length);
break;
case BIGNUM_DTOA_FIXED:
BignumToFixed(requested_digits, decimal_point,
&numerator, &denominator,
buffer, length);
break;
case BIGNUM_DTOA_PRECISION:
GenerateCountedDigits(requested_digits, decimal_point,
&numerator, &denominator,
buffer, length);
break;
default:
UNREACHABLE();
}
buffer[*length] = '\0';
}
// The procedure starts generating digits from the left to the right and stops
// when the generated digits yield the shortest decimal representation of v. A
// decimal representation of v is a number lying closer to v than to any other
// double, so it converts to v when read.
//
// This is true if d, the decimal representation, is between m- and m+, the
// upper and lower boundaries. d must be strictly between them if !is_even.
// m- := (numerator - delta_minus) / denominator
// m+ := (numerator + delta_plus) / denominator
//
// Precondition: 0 <= (numerator+delta_plus) / denominator < 10.
// If 1 <= (numerator+delta_plus) / denominator < 10 then no leading 0 digit
// will be produced. This should be the standard precondition.
static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus,
bool is_even,
Vector<char> buffer, int* length) {
// Small optimization: if delta_minus and delta_plus are the same just reuse
// one of the two bignums.
if (Bignum::Equal(*delta_minus, *delta_plus)) {
delta_plus = delta_minus;
}
*length = 0;
for (;;) {
uint16_t digit;
digit = numerator->DivideModuloIntBignum(*denominator);
ASSERT(digit <= 9); // digit is a uint16_t and therefore always positive.
// digit = numerator / denominator (integer division).
// numerator = numerator % denominator.
buffer[(*length)++] = static_cast<char>(digit + '0');
// Can we stop already?
// If the remainder of the division is less than the distance to the lower
// boundary we can stop. In this case we simply round down (discarding the
// remainder).
// Similarly we test if we can round up (using the upper boundary).
bool in_delta_room_minus;
bool in_delta_room_plus;
if (is_even) {
in_delta_room_minus = Bignum::LessEqual(*numerator, *delta_minus);
} else {
in_delta_room_minus = Bignum::Less(*numerator, *delta_minus);
}
if (is_even) {
in_delta_room_plus =
Bignum::PlusCompare(*numerator, *delta_plus, *denominator) >= 0;
} else {
in_delta_room_plus =
Bignum::PlusCompare(*numerator, *delta_plus, *denominator) > 0;
}
if (!in_delta_room_minus && !in_delta_room_plus) {
// Prepare for next iteration.
numerator->Times10();
delta_minus->Times10();
// We optimized delta_plus to be equal to delta_minus (if they share the
// same value). So don't multiply delta_plus if they point to the same
// object.
if (delta_minus != delta_plus) {
delta_plus->Times10();
}
} else if (in_delta_room_minus && in_delta_room_plus) {
// Let's see if 2*numerator < denominator.
// If yes, then the next digit would be < 5 and we can round down.
int compare = Bignum::PlusCompare(*numerator, *numerator, *denominator);
if (compare < 0) {
// Remaining digits are less than .5. -> Round down (== do nothing).
} else if (compare > 0) {
// Remaining digits are more than .5 of denominator. -> Round up.
// Note that the last digit could not be a '9' as otherwise the whole
// loop would have stopped earlier.
// We still have an assert here in case the preconditions were not
// satisfied.
ASSERT(buffer[(*length) - 1] != '9');
buffer[(*length) - 1]++;
} else {
// Halfway case.
// TODO(floitsch): need a way to solve half-way cases.
// For now let's round towards even (since this is what Gay seems to
// do).
if ((buffer[(*length) - 1] - '0') % 2 == 0) {
// Round down => Do nothing.
} else {
ASSERT(buffer[(*length) - 1] != '9');
buffer[(*length) - 1]++;
}
}
return;
} else if (in_delta_room_minus) {
// Round down (== do nothing).
return;
} else { // in_delta_room_plus
// Round up.
// Note again that the last digit could not be '9' since this would have
// stopped the loop earlier.
// We still have an ASSERT here, in case the preconditions were not
// satisfied.
ASSERT(buffer[(*length) -1] != '9');
buffer[(*length) - 1]++;
return;
}
}
}
// Let v = numerator / denominator < 10.
// Then we generate 'count' digits of d = x.xxxxx... (without the decimal point)
// from left to right. Once 'count' digits have been produced we decide wether
// to round up or down. Remainders of exactly .5 round upwards. Numbers such
// as 9.999999 propagate a carry all the way, and change the
// exponent (decimal_point), when rounding upwards.
static void GenerateCountedDigits(int count, int* decimal_point,
Bignum* numerator, Bignum* denominator,
Vector<char> buffer, int* length) {
ASSERT(count >= 0);
for (int i = 0; i < count - 1; ++i) {
uint16_t digit;
digit = numerator->DivideModuloIntBignum(*denominator);
ASSERT(digit <= 9); // digit is a uint16_t and therefore always positive.
// digit = numerator / denominator (integer division).
// numerator = numerator % denominator.
buffer[i] = static_cast<char>(digit + '0');
// Prepare for next iteration.
numerator->Times10();
}
// Generate the last digit.
uint16_t digit;
digit = numerator->DivideModuloIntBignum(*denominator);
if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
digit++;
}
ASSERT(digit <= 10);
buffer[count - 1] = static_cast<char>(digit + '0');
// Correct bad digits (in case we had a sequence of '9's). Propagate the
// carry until we hat a non-'9' or til we reach the first digit.
for (int i = count - 1; i > 0; --i) {
if (buffer[i] != '0' + 10) break;
buffer[i] = '0';
buffer[i - 1]++;
}
if (buffer[0] == '0' + 10) {
// Propagate a carry past the top place.
buffer[0] = '1';
(*decimal_point)++;
}
*length = count;
}
// Generates 'requested_digits' after the decimal point. It might omit
// trailing '0's. If the input number is too small then no digits at all are
// generated (ex.: 2 fixed digits for 0.00001).
//
// Input verifies: 1 <= (numerator + delta) / denominator < 10.
static void BignumToFixed(int requested_digits, int* decimal_point,
Bignum* numerator, Bignum* denominator,
Vector<char>(buffer), int* length) {
// Note that we have to look at more than just the requested_digits, since
// a number could be rounded up. Example: v=0.5 with requested_digits=0.
// Even though the power of v equals 0 we can't just stop here.
if (-(*decimal_point) > requested_digits) {
// The number is definitively too small.
// Ex: 0.001 with requested_digits == 1.
// Set decimal-point to -requested_digits. This is what Gay does.
// Note that it should not have any effect anyways since the string is
// empty.
*decimal_point = -requested_digits;
*length = 0;
return;
} else if (-(*decimal_point) == requested_digits) {
// We only need to verify if the number rounds down or up.
// Ex: 0.04 and 0.06 with requested_digits == 1.
ASSERT(*decimal_point == -requested_digits);
// Initially the fraction lies in range (1, 10]. Multiply the denominator
// by 10 so that we can compare more easily.
denominator->Times10();
if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
// If the fraction is >= 0.5 then we have to include the rounded
// digit.
buffer[0] = '1';
*length = 1;
(*decimal_point)++;
} else {
// Note that we caught most of similar cases earlier.
*length = 0;
}
return;
} else {
// The requested digits correspond to the digits after the point.
// The variable 'needed_digits' includes the digits before the point.
int needed_digits = (*decimal_point) + requested_digits;
GenerateCountedDigits(needed_digits, decimal_point,
numerator, denominator,
buffer, length);
}
}
// Returns an estimation of k such that 10^(k-1) <= v < 10^k where
// v = f * 2^exponent and 2^52 <= f < 2^53.
// v is hence a normalized double with the given exponent. The output is an
// approximation for the exponent of the decimal approimation .digits * 10^k.
//
// The result might undershoot by 1 in which case 10^k <= v < 10^k+1.
// Note: this property holds for v's upper boundary m+ too.
// 10^k <= m+ < 10^k+1.
// (see explanation below).
//
// Examples:
// EstimatePower(0) => 16
// EstimatePower(-52) => 0
//
// Note: e >= 0 => EstimatedPower(e) > 0. No similar claim can be made for e<0.
static int EstimatePower(int exponent) {
// This function estimates log10 of v where v = f*2^e (with e == exponent).
// Note that 10^floor(log10(v)) <= v, but v <= 10^ceil(log10(v)).
// Note that f is bounded by its container size. Let p = 53 (the double's
// significand size). Then 2^(p-1) <= f < 2^p.
//
// Given that log10(v) == log2(v)/log2(10) and e+(len(f)-1) is quite close
// to log2(v) the function is simplified to (e+(len(f)-1)/log2(10)).
// The computed number undershoots by less than 0.631 (when we compute log3
// and not log10).
//
// Optimization: since we only need an approximated result this computation
// can be performed on 64 bit integers. On x86/x64 architecture the speedup is
// not really measurable, though.
//
// Since we want to avoid overshooting we decrement by 1e10 so that
// floating-point imprecisions don't affect us.
//
// Explanation for v's boundary m+: the computation takes advantage of
// the fact that 2^(p-1) <= f < 2^p. Boundaries still satisfy this requirement
// (even for denormals where the delta can be much more important).
const double k1Log10 = 0.30102999566398114; // 1/lg(10)
// For doubles len(f) == 53 (don't forget the hidden bit).
const int kSignificandSize = Double::kSignificandSize;
double estimate = ceil((exponent + kSignificandSize - 1) * k1Log10 - 1e-10);
return static_cast<int>(estimate);
}
// See comments for InitialScaledStartValues.
static void InitialScaledStartValuesPositiveExponent(
uint64_t significand, int exponent,
int estimated_power, bool need_boundary_deltas,
Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus) {
// A positive exponent implies a positive power.
ASSERT(estimated_power >= 0);
// Since the estimated_power is positive we simply multiply the denominator
// by 10^estimated_power.
// numerator = v.
numerator->AssignUInt64(significand);
numerator->ShiftLeft(exponent);
// denominator = 10^estimated_power.
denominator->AssignPowerUInt16(10, estimated_power);
if (need_boundary_deltas) {
// Introduce a common denominator so that the deltas to the boundaries are
// integers.
denominator->ShiftLeft(1);
numerator->ShiftLeft(1);
// Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
// denominator (of 2) delta_plus equals 2^e.
delta_plus->AssignUInt16(1);
delta_plus->ShiftLeft(exponent);
// Same for delta_minus. The adjustments if f == 2^p-1 are done later.
delta_minus->AssignUInt16(1);
delta_minus->ShiftLeft(exponent);
}
}
// See comments for InitialScaledStartValues
static void InitialScaledStartValuesNegativeExponentPositivePower(
uint64_t significand, int exponent,
int estimated_power, bool need_boundary_deltas,
Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus) {
// v = f * 2^e with e < 0, and with estimated_power >= 0.
// This means that e is close to 0 (have a look at how estimated_power is
// computed).
// numerator = significand
// since v = significand * 2^exponent this is equivalent to
// numerator = v * / 2^-exponent
numerator->AssignUInt64(significand);
// denominator = 10^estimated_power * 2^-exponent (with exponent < 0)
denominator->AssignPowerUInt16(10, estimated_power);
denominator->ShiftLeft(-exponent);
if (need_boundary_deltas) {
// Introduce a common denominator so that the deltas to the boundaries are
// integers.
denominator->ShiftLeft(1);
numerator->ShiftLeft(1);
// Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
// denominator (of 2) delta_plus equals 2^e.
// Given that the denominator already includes v's exponent the distance
// to the boundaries is simply 1.
delta_plus->AssignUInt16(1);
// Same for delta_minus. The adjustments if f == 2^p-1 are done later.
delta_minus->AssignUInt16(1);
}
}
// See comments for InitialScaledStartValues
static void InitialScaledStartValuesNegativeExponentNegativePower(
uint64_t significand, int exponent,
int estimated_power, bool need_boundary_deltas,
Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus) {
// Instead of multiplying the denominator with 10^estimated_power we
// multiply all values (numerator and deltas) by 10^-estimated_power.
// Use numerator as temporary container for power_ten.
Bignum* power_ten = numerator;
power_ten->AssignPowerUInt16(10, -estimated_power);
if (need_boundary_deltas) {
// Since power_ten == numerator we must make a copy of 10^estimated_power
// before we complete the computation of the numerator.
// delta_plus = delta_minus = 10^estimated_power
delta_plus->AssignBignum(*power_ten);
delta_minus->AssignBignum(*power_ten);
}
// numerator = significand * 2 * 10^-estimated_power
// since v = significand * 2^exponent this is equivalent to
// numerator = v * 10^-estimated_power * 2 * 2^-exponent.
// Remember: numerator has been abused as power_ten. So no need to assign it
// to itself.
ASSERT(numerator == power_ten);
numerator->MultiplyByUInt64(significand);
// denominator = 2 * 2^-exponent with exponent < 0.
denominator->AssignUInt16(1);
denominator->ShiftLeft(-exponent);
if (need_boundary_deltas) {
// Introduce a common denominator so that the deltas to the boundaries are
// integers.
numerator->ShiftLeft(1);
denominator->ShiftLeft(1);
// With this shift the boundaries have their correct value, since
// delta_plus = 10^-estimated_power, and
// delta_minus = 10^-estimated_power.
// These assignments have been done earlier.
// The adjustments if f == 2^p-1 (lower boundary is closer) are done later.
}
}
// Let v = significand * 2^exponent.
// Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
// and denominator. The functions GenerateShortestDigits and
// GenerateCountedDigits will then convert this ratio to its decimal
// representation d, with the required accuracy.
// Then d * 10^estimated_power is the representation of v.
// (Note: the fraction and the estimated_power might get adjusted before
// generating the decimal representation.)
//
// The initial start values consist of:
// - a scaled numerator: s.t. numerator/denominator == v / 10^estimated_power.
// - a scaled (common) denominator.
// optionally (used by GenerateShortestDigits to decide if it has the shortest
// decimal converting back to v):
// - v - m-: the distance to the lower boundary.
// - m+ - v: the distance to the upper boundary.
//
// v, m+, m-, and therefore v - m- and m+ - v all share the same denominator.
//
// Let ep == estimated_power, then the returned values will satisfy:
// v / 10^ep = numerator / denominator.
// v's boundarys m- and m+:
// m- / 10^ep == v / 10^ep - delta_minus / denominator
// m+ / 10^ep == v / 10^ep + delta_plus / denominator
// Or in other words:
// m- == v - delta_minus * 10^ep / denominator;
// m+ == v + delta_plus * 10^ep / denominator;
//
// Since 10^(k-1) <= v < 10^k (with k == estimated_power)
// or 10^k <= v < 10^(k+1)
// we then have 0.1 <= numerator/denominator < 1
// or 1 <= numerator/denominator < 10
//
// It is then easy to kickstart the digit-generation routine.
//
// The boundary-deltas are only filled if the mode equals BIGNUM_DTOA_SHORTEST
// or BIGNUM_DTOA_SHORTEST_SINGLE.
static void InitialScaledStartValues(uint64_t significand,
int exponent,
bool lower_boundary_is_closer,
int estimated_power,
bool need_boundary_deltas,
Bignum* numerator,
Bignum* denominator,
Bignum* delta_minus,
Bignum* delta_plus) {
if (exponent >= 0) {
InitialScaledStartValuesPositiveExponent(
significand, exponent, estimated_power, need_boundary_deltas,
numerator, denominator, delta_minus, delta_plus);
} else if (estimated_power >= 0) {
InitialScaledStartValuesNegativeExponentPositivePower(
significand, exponent, estimated_power, need_boundary_deltas,
numerator, denominator, delta_minus, delta_plus);
} else {
InitialScaledStartValuesNegativeExponentNegativePower(
significand, exponent, estimated_power, need_boundary_deltas,
numerator, denominator, delta_minus, delta_plus);
}
if (need_boundary_deltas && lower_boundary_is_closer) {
// The lower boundary is closer at half the distance of "normal" numbers.
// Increase the common denominator and adapt all but the delta_minus.
denominator->ShiftLeft(1); // *2
numerator->ShiftLeft(1); // *2
delta_plus->ShiftLeft(1); // *2
}
}
// This routine multiplies numerator/denominator so that its values lies in the
// range 1-10. That is after a call to this function we have:
// 1 <= (numerator + delta_plus) /denominator < 10.
// Let numerator the input before modification and numerator' the argument
// after modification, then the output-parameter decimal_point is such that
// numerator / denominator * 10^estimated_power ==
// numerator' / denominator' * 10^(decimal_point - 1)
// In some cases estimated_power was too low, and this is already the case. We
// then simply adjust the power so that 10^(k-1) <= v < 10^k (with k ==
// estimated_power) but do not touch the numerator or denominator.
// Otherwise the routine multiplies the numerator and the deltas by 10.
static void FixupMultiply10(int estimated_power, bool is_even,
int* decimal_point,
Bignum* numerator, Bignum* denominator,
Bignum* delta_minus, Bignum* delta_plus) {
bool in_range;
if (is_even) {
// For IEEE doubles half-way cases (in decimal system numbers ending with 5)
// are rounded to the closest floating-point number with even significand.
in_range = Bignum::PlusCompare(*numerator, *delta_plus, *denominator) >= 0;
} else {
in_range = Bignum::PlusCompare(*numerator, *delta_plus, *denominator) > 0;
}
if (in_range) {
// Since numerator + delta_plus >= denominator we already have
// 1 <= numerator/denominator < 10. Simply update the estimated_power.
*decimal_point = estimated_power + 1;
} else {
*decimal_point = estimated_power;
numerator->Times10();
if (Bignum::Equal(*delta_minus, *delta_plus)) {
delta_minus->Times10();
delta_plus->AssignBignum(*delta_minus);
} else {
delta_minus->Times10();
delta_plus->Times10();
}
}
}
} // namespace double_conversion
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/bignum-dtoa.h
================================================
// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef DOUBLE_CONVERSION_BIGNUM_DTOA_H_
#define DOUBLE_CONVERSION_BIGNUM_DTOA_H_
#include "utils.h"
namespace double_conversion {
enum BignumDtoaMode {
// Return the shortest correct representation.
// For example the output of 0.299999999999999988897 is (the less accurate but
// correct) 0.3.
BIGNUM_DTOA_SHORTEST,
// Same as BIGNUM_DTOA_SHORTEST but for single-precision floats.
BIGNUM_DTOA_SHORTEST_SINGLE,
// Return a fixed number of digits after the decimal point.
// For instance fixed(0.1, 4) becomes 0.1000
// If the input number is big, the output will be big.
BIGNUM_DTOA_FIXED,
// Return a fixed number of digits, no matter what the exponent is.
BIGNUM_DTOA_PRECISION
};
// Converts the given double 'v' to ascii.
// The result should be interpreted as buffer * 10^(point-length).
// The buffer will be null-terminated.
//
// The input v must be > 0 and different from NaN, and Infinity.
//
// The output depends on the given mode:
// - SHORTEST: produce the least amount of digits for which the internal
// identity requirement is still satisfied. If the digits are printed
// (together with the correct exponent) then reading this number will give
// 'v' again. The buffer will choose the representation that is closest to
// 'v'. If there are two at the same distance, than the number is round up.
// In this mode the 'requested_digits' parameter is ignored.
// - FIXED: produces digits necessary to print a given number with
// 'requested_digits' digits after the decimal point. The produced digits
// might be too short in which case the caller has to fill the gaps with '0's.
// Example: toFixed(0.001, 5) is allowed to return buffer="1", point=-2.
// Halfway cases are rounded up. The call toFixed(0.15, 2) thus returns
// buffer="2", point=0.
// Note: the length of the returned buffer has no meaning wrt the significance
// of its digits. That is, just because it contains '0's does not mean that
// any other digit would not satisfy the internal identity requirement.
// - PRECISION: produces 'requested_digits' where the first digit is not '0'.
// Even though the length of produced digits usually equals
// 'requested_digits', the function is allowed to return fewer digits, in
// which case the caller has to fill the missing digits with '0's.
// Halfway cases are again rounded up.
// 'BignumDtoa' expects the given buffer to be big enough to hold all digits
// and a terminating null-character.
void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
Vector<char> buffer, int* length, int* point);
} // namespace double_conversion
#endif // DOUBLE_CONVERSION_BIGNUM_DTOA_H_
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/bignum.cc
================================================
// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "bignum.h"
#include "utils.h"
namespace double_conversion {
Bignum::Bignum()
: bigits_(bigits_buffer_, kBigitCapacity), used_digits_(0), exponent_(0) {
for (int i = 0; i < kBigitCapacity; ++i) {
bigits_[i] = 0;
}
}
template<typename S>
static int BitSize(S value) {
(void) value; // Mark variable as used.
return 8 * sizeof(value);
}
// Guaranteed to lie in one Bigit.
void Bignum::AssignUInt16(uint16_t value) {
ASSERT(kBigitSize >= BitSize(value));
Zero();
if (value == 0) return;
EnsureCapacity(1);
bigits_[0] = value;
used_digits_ = 1;
}
void Bignum::AssignUInt64(uint64_t value) {
const int kUInt64Size = 64;
Zero();
if (value == 0) return;
int needed_bigits = kUInt64Size / kBigitSize + 1;
EnsureCapacity(needed_bigits);
for (int i = 0; i < needed_bigits; ++i) {
bigits_[i] = value & kBigitMask;
value = value >> kBigitSize;
}
used_digits_ = needed_bigits;
Clamp();
}
void Bignum::AssignBignum(const Bignum& other) {
exponent_ = other.exponent_;
for (int i = 0; i < other.used_digits_; ++i) {
bigits_[i] = other.bigits_[i];
}
// Clear the excess digits (if there were any).
for (int i = other.used_digits_; i < used_digits_; ++i) {
bigits_[i] = 0;
}
used_digits_ = other.used_digits_;
}
static uint64_t ReadUInt64(Vector<const char> buffer,
int from,
int digits_to_read) {
uint64_t result = 0;
for (int i = from; i < from + digits_to_read; ++i) {
int digit = buffer[i] - '0';
ASSERT(0 <= digit && digit <= 9);
result = result * 10 + digit;
}
return result;
}
void Bignum::AssignDecimalString(Vector<const char> value) {
// 2^64 = 18446744073709551616 > 10^19
const int kMaxUint64DecimalDigits = 19;
Zero();
int length = value.length();
int pos = 0;
// Let's just say that each digit needs 4 bits.
while (length >= kMaxUint64DecimalDigits) {
uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits);
pos += kMaxUint64DecimalDigits;
length -= kMaxUint64DecimalDigits;
MultiplyByPowerOfTen(kMaxUint64DecimalDigits);
AddUInt64(digits);
}
uint64_t digits = ReadUInt64(value, pos, length);
MultiplyByPowerOfTen(length);
AddUInt64(digits);
Clamp();
}
static int HexCharValue(char c) {
if ('0' <= c && c <= '9') return c - '0';
if ('a' <= c && c <= 'f') return 10 + c - 'a';
ASSERT('A' <= c && c <= 'F');
return 10 + c - 'A';
}
void Bignum::AssignHexString(Vector<const char> value) {
Zero();
int length = value.length();
int needed_bigits = length * 4 / kBigitSize + 1;
EnsureCapacity(needed_bigits);
int string_index = length - 1;
for (int i = 0; i < needed_bigits - 1; ++i) {
// These bigits are guaranteed to be "full".
Chunk current_bigit = 0;
for (int j = 0; j < kBigitSize / 4; j++) {
current_bigit += HexCharValue(value[string_index--]) << (j * 4);
}
bigits_[i] = current_bigit;
}
used_digits_ = needed_bigits - 1;
Chunk most_significant_bigit = 0; // Could be = 0;
for (int j = 0; j <= string_index; ++j) {
most_significant_bigit <<= 4;
most_significant_bigit += HexCharValue(value[j]);
}
if (most_significant_bigit != 0) {
bigits_[used_digits_] = most_significant_bigit;
used_digits_++;
}
Clamp();
}
void Bignum::AddUInt64(uint64_t operand) {
if (operand == 0) return;
Bignum other;
other.AssignUInt64(operand);
AddBignum(other);
}
void Bignum::AddBignum(const Bignum& other) {
ASSERT(IsClamped());
ASSERT(other.IsClamped());
// If this has a greater exponent than other append zero-bigits to this.
// After this call exponent_ <= other.exponent_.
Align(other);
// There are two possibilities:
// aaaaaaaaaaa 0000 (where the 0s represent a's exponent)
// bbbbb 00000000
// ----------------
// ccccccccccc 0000
// or
// aaaaaaaaaa 0000
// bbbbbbbbb 0000000
// -----------------
// cccccccccccc 0000
// In both cases we might need a carry bigit.
EnsureCapacity(1 + Max(BigitLength(), other.BigitLength()) - exponent_);
Chunk carry = 0;
int bigit_pos = other.exponent_ - exponent_;
ASSERT(bigit_pos >= 0);
for (int i = 0; i < other.used_digits_; ++i) {
Chunk sum = bigits_[bigit_pos] + other.bigits_[i] + carry;
bigits_[bigit_pos] = sum & kBigitMask;
carry = sum >> kBigitSize;
bigit_pos++;
}
while (carry != 0) {
Chunk sum = bigits_[bigit_pos] + carry;
bigits_[bigit_pos] = sum & kBigitMask;
carry = sum >> kBigitSize;
bigit_pos++;
}
used_digits_ = Max(bigit_pos, used_digits_);
ASSERT(IsClamped());
}
void Bignum::SubtractBignum(const Bignum& other) {
ASSERT(IsClamped());
ASSERT(other.IsClamped());
// We require this to be bigger than other.
ASSERT(LessEqual(other, *this));
Align(other);
int offset = other.exponent_ - exponent_;
Chunk borrow = 0;
int i;
for (i = 0; i < other.used_digits_; ++i) {
ASSERT((borrow == 0) || (borrow == 1));
Chunk difference = bigits_[i + offset] - other.bigits_[i] - borrow;
bigits_[i + offset] = difference & kBigitMask;
borrow = difference >> (kChunkSize - 1);
}
while (borrow != 0) {
Chunk difference = bigits_[i + offset] - borrow;
bigits_[i + offset] = difference & kBigitMask;
borrow = difference >> (kChunkSize - 1);
++i;
}
Clamp();
}
void Bignum::ShiftLeft(int shift_amount) {
if (used_digits_ == 0) return;
exponent_ += shift_amount / kBigitSize;
int local_shift = shift_amount % kBigitSize;
EnsureCapacity(used_digits_ + 1);
BigitsShiftLeft(local_shift);
}
void Bignum::MultiplyByUInt32(uint32_t factor) {
if (factor == 1) return;
if (factor == 0) {
Zero();
return;
}
if (used_digits_ == 0) return;
// The product of a bigit with the factor is of size kBigitSize + 32.
// Assert that this number + 1 (for the carry) fits into double chunk.
ASSERT(kDoubleChunkSize >= kBigitSize + 32 + 1);
DoubleChunk carry = 0;
for (int i = 0; i < used_digits_; ++i) {
DoubleChunk product = static_cast<DoubleChunk>(factor) * bigits_[i] + carry;
bigits_[i] = static_cast<Chunk>(product & kBigitMask);
carry = (product >> kBigitSize);
}
while (carry != 0) {
EnsureCapacity(used_digits_ + 1);
bigits_[used_digits_] = carry & kBigitMask;
used_digits_++;
carry >>= kBigitSize;
}
}
void Bignum::MultiplyByUInt64(uint64_t factor) {
if (factor == 1) return;
if (factor == 0) {
Zero();
return;
}
ASSERT(kBigitSize < 32);
uint64_t carry = 0;
uint64_t low = factor & 0xFFFFFFFF;
uint64_t high = factor >> 32;
for (int i = 0; i < used_digits_; ++i) {
uint64_t product_low = low * bigits_[i];
uint64_t product_high = high * bigits_[i];
uint64_t tmp = (carry & kBigitMask) + product_low;
bigits_[i] = tmp & kBigitMask;
carry = (carry >> kBigitSize) + (tmp >> kBigitSize) +
(product_high << (32 - kBigitSize));
}
while (carry != 0) {
EnsureCapacity(used_digits_ + 1);
bigits_[used_digits_] = carry & kBigitMask;
used_digits_++;
carry >>= kBigitSize;
}
}
void Bignum::MultiplyByPowerOfTen(int exponent) {
const uint64_t kFive27 = UINT64_2PART_C(0x6765c793, fa10079d);
const uint16_t kFive1 = 5;
const uint16_t kFive2 = kFive1 * 5;
const uint16_t kFive3 = kFive2 * 5;
const uint16_t kFive4 = kFive3 * 5;
const uint16_t kFive5 = kFive4 * 5;
const uint16_t kFive6 = kFive5 * 5;
const uint32_t kFive7 = kFive6 * 5;
const uint32_t kFive8 = kFive7 * 5;
const uint32_t kFive9 = kFive8 * 5;
const uint32_t kFive10 = kFive9 * 5;
const uint32_t kFive11 = kFive10 * 5;
const uint32_t kFive12 = kFive11 * 5;
const uint32_t kFive13 = kFive12 * 5;
const uint32_t kFive1_to_12[] =
{ kFive1, kFive2, kFive3, kFive4, kFive5, kFive6,
kFive7, kFive8, kFive9, kFive10, kFive11, kFive12 };
ASSERT(exponent >= 0);
if (exponent == 0) return;
if (used_digits_ == 0) return;
// We shift by exponent at the end just before returning.
int remaining_exponent = exponent;
while (remaining_exponent >= 27) {
MultiplyByUInt64(kFive27);
remaining_exponent -= 27;
}
while (remaining_exponent >= 13) {
MultiplyByUInt32(kFive13);
remaining_exponent -= 13;
}
if (remaining_exponent > 0) {
MultiplyByUInt32(kFive1_to_12[remaining_exponent - 1]);
}
ShiftLeft(exponent);
}
void Bignum::Square() {
ASSERT(IsClamped());
int product_length = 2 * used_digits_;
EnsureCapacity(product_length);
// Comba multiplication: compute each column separately.
// Example: r = a2a1a0 * b2b1b0.
// r = 1 * a0b0 +
// 10 * (a1b0 + a0b1) +
// 100 * (a2b0 + a1b1 + a0b2) +
// 1000 * (a2b1 + a1b2) +
// 10000 * a2b2
//
// In the worst case we have to accumulate nb-digits products of digit*digit.
//
// Assert that the additional number of bits in a DoubleChunk are enough to
// sum up used_digits of Bigit*Bigit.
if ((1 << (2 * (kChunkSize - kBigitSize))) <= used_digits_) {
UNIMPLEMENTED();
}
DoubleChunk accumulator = 0;
// First shift the digits so we don't overwrite them.
int copy_offset = used_digits_;
for (int i = 0; i < used_digits_; ++i) {
bigits_[copy_offset + i] = bigits_[i];
}
// We have two loops to avoid some 'if's in the loop.
for (int i = 0; i < used_digits_; ++i) {
// Process temporary digit i with power i.
// The sum of the two indices must be equal to i.
int bigit_index1 = i;
int bigit_index2 = 0;
// Sum all of the sub-products.
while (bigit_index1 >= 0) {
Chunk chunk1 = bigits_[copy_offset + bigit_index1];
Chunk chunk2 = bigits_[copy_offset + bigit_index2];
accumulator += static_cast<DoubleChunk>(chunk1) * chunk2;
bigit_index1--;
bigit_index2++;
}
bigits_[i] = static_cast<Chunk>(accumulator) & kBigitMask;
accumulator >>= kBigitSize;
}
for (int i = used_digits_; i < product_length; ++i) {
int bigit_index1 = used_digits_ - 1;
int bigit_index2 = i - bigit_index1;
// Invariant: sum of both indices is again equal to i.
// Inner loop runs 0 times on last iteration, emptying accumulator.
while (bigit_index2 < used_digits_) {
Chunk chunk1 = bigits_[copy_offset + bigit_index1];
Chunk chunk2 = bigits_[copy_offset + bigit_index2];
accumulator += static_cast<DoubleChunk>(chunk1) * chunk2;
bigit_index1--;
bigit_index2++;
}
// The overwritten bigits_[i] will never be read in further loop iterations,
// because bigit_index1 and bigit_index2 are always greater
// than i - used_digits_.
bigits_[i] = static_cast<Chunk>(accumulator) & kBigitMask;
accumulator >>= kBigitSize;
}
// Since the result was guaranteed to lie inside the number the
// accumulator must be 0 now.
ASSERT(accumulator == 0);
// Don't forget to update the used_digits and the exponent.
used_digits_ = product_length;
exponent_ *= 2;
Clamp();
}
void Bignum::AssignPowerUInt16(uint16_t base, int power_exponent) {
ASSERT(base != 0);
ASSERT(power_exponent >= 0);
if (power_exponent == 0) {
AssignUInt16(1);
return;
}
Zero();
int shifts = 0;
// We expect base to be in range 2-32, and most often to be 10.
// It does not make much sense to implement different algorithms for counting
// the bits.
while ((base & 1) == 0) {
base >>= 1;
shifts++;
}
int bit_size = 0;
int tmp_base = base;
while (tmp_base != 0) {
tmp_base >>= 1;
bit_size++;
}
int final_size = bit_size * power_exponent;
// 1 extra bigit for the shifting, and one for rounded final_size.
EnsureCapacity(final_size / kBigitSize + 2);
// Left to Right exponentiation.
int mask = 1;
while (power_exponent >= mask) mask <<= 1;
// The mask is now pointing to the bit above the most significant 1-bit of
// power_exponent.
// Get rid of first 1-bit;
mask >>= 2;
uint64_t this_value = base;
bool delayed_multipliciation = false;
const uint64_t max_32bits = 0xFFFFFFFF;
while (mask != 0 && this_value <= max_32bits) {
this_value = this_value * this_value;
// Verify that there is enough space in this_value to perform the
// multiplication. The first bit_size bits must be 0.
if ((power_exponent & mask) != 0) {
uint64_t base_bits_mask =
~((static_cast<uint64_t>(1) << (64 - bit_size)) - 1);
bool high_bits_zero = (this_value & base_bits_mask) == 0;
if (high_bits_zero) {
this_value *= base;
} else {
delayed_multipliciation = true;
}
}
mask >>= 1;
}
AssignUInt64(this_value);
if (delayed_multipliciation) {
MultiplyByUInt32(base);
}
// Now do the same thing as a bignum.
while (mask != 0) {
Square();
if ((power_exponent & mask) != 0) {
MultiplyByUInt32(base);
}
mask >>= 1;
}
// And finally add the saved shifts.
ShiftLeft(shifts * power_exponent);
}
// Precondition: this/other < 16bit.
uint16_t Bignum::DivideModuloIntBignum(const Bignum& other) {
ASSERT(IsClamped());
ASSERT(other.IsClamped());
ASSERT(other.used_digits_ > 0);
// Easy case: if we have less digits than the divisor than the result is 0.
// Note: this handles the case where this == 0, too.
if (BigitLength() < other.BigitLength()) {
return 0;
}
Align(other);
uint16_t result = 0;
// Start by removing multiples of 'other' until both numbers have the same
// number of digits.
while (BigitLength() > other.BigitLength()) {
// This naive approach is extremely inefficient if `this` divided by other
// is big. This function is implemented for doubleToString where
// the result should be small (less than 10).
ASSERT(other.bigits_[other.used_digits_ - 1] >= ((1 << kBigitSize) / 16));
ASSERT(bigits_[used_digits_ - 1] < 0x10000);
// Remove the multiples of the first digit.
// Example this = 23 and other equals 9. -> Remove 2 multiples.
result += static_cast<uint16_t>(bigits_[used_digits_ - 1]);
SubtractTimes(other, bigits_[used_digits_ - 1]);
}
ASSERT(BigitLength() == other.BigitLength());
// Both bignums are at the same length now.
// Since other has more than 0 digits we know that the access to
// bigits_[used_digits_ - 1] is safe.
Chunk this_bigit = bigits_[used_digits_ - 1];
Chunk other_bigit = other.bigits_[other.used_digits_ - 1];
if (other.used_digits_ == 1) {
// Shortcut for easy (and common) case.
int quotient = this_bigit / other_bigit;
bigits_[used_digits_ - 1] = this_bigit - other_bigit * quotient;
ASSERT(quotient < 0x10000);
result += static_cast<uint16_t>(quotient);
Clamp();
return result;
}
int division_estimate = this_bigit / (other_bigit + 1);
ASSERT(division_estimate < 0x10000);
result += static_cast<uint16_t>(division_estimate);
SubtractTimes(other, division_estimate);
if (other_bigit * (division_estimate + 1) > this_bigit) {
// No need to even try to subtract. Even if other's remaining digits were 0
// another subtraction would be too much.
return result;
}
while (LessEqual(other, *this)) {
SubtractBignum(other);
result++;
}
return result;
}
template<typename S>
static int SizeInHexChars(S number) {
ASSERT(number > 0);
int result = 0;
while (number != 0) {
number >>= 4;
result++;
}
return result;
}
static char HexCharOfValue(int value) {
ASSERT(0 <= value && value <= 16);
if (value < 10) return static_cast<char>(value + '0');
return static_cast<char>(value - 10 + 'A');
}
bool Bignum::ToHexString(char* buffer, int buffer_size) const {
ASSERT(IsClamped());
// Each bigit must be printable as separate hex-character.
ASSERT(kBigitSize % 4 == 0);
const int kHexCharsPerBigit = kBigitSize / 4;
if (used_digits_ == 0) {
if (buffer_size < 2) return false;
buffer[0] = '0';
buffer[1] = '\0';
return true;
}
// We add 1 for the terminating '\0' character.
int needed_chars = (BigitLength() - 1) * kHexCharsPerBigit +
SizeInHexChars(bigits_[used_digits_ - 1]) + 1;
if (needed_chars > buffer_size) return false;
int string_index = needed_chars - 1;
buffer[string_index--] = '\0';
for (int i = 0; i < exponent_; ++i) {
for (int j = 0; j < kHexCharsPerBigit; ++j) {
buffer[string_index--] = '0';
}
}
for (int i = 0; i < used_digits_ - 1; ++i) {
Chunk current_bigit = bigits_[i];
for (int j = 0; j < kHexCharsPerBigit; ++j) {
buffer[string_index--] = HexCharOfValue(current_bigit & 0xF);
current_bigit >>= 4;
}
}
// And finally the last bigit.
Chunk most_significant_bigit = bigits_[used_digits_ - 1];
while (most_significant_bigit != 0) {
buffer[string_index--] = HexCharOfValue(most_significant_bigit & 0xF);
most_significant_bigit >>= 4;
}
return true;
}
Bignum::Chunk Bignum::BigitAt(int index) const {
if (index >= BigitLength()) return 0;
if (index < exponent_) return 0;
return bigits_[index - exponent_];
}
int Bignum::Compare(const Bignum& a, const Bignum& b) {
ASSERT(a.IsClamped());
ASSERT(b.IsClamped());
int bigit_length_a = a.BigitLength();
int bigit_length_b = b.BigitLength();
if (bigit_length_a < bigit_length_b) return -1;
if (bigit_length_a > bigit_length_b) return +1;
for (int i = bigit_length_a - 1; i >= Min(a.exponent_, b.exponent_); --i) {
Chunk bigit_a = a.BigitAt(i);
Chunk bigit_b = b.BigitAt(i);
if (bigit_a < bigit_b) return -1;
if (bigit_a > bigit_b) return +1;
// Otherwise they are equal up to this digit. Try the next digit.
}
return 0;
}
int Bignum::PlusCompare(const Bignum& a, const Bignum& b, const Bignum& c) {
ASSERT(a.IsClamped());
ASSERT(b.IsClamped());
ASSERT(c.IsClamped());
if (a.BigitLength() < b.BigitLength()) {
return PlusCompare(b, a, c);
}
if (a.BigitLength() + 1 < c.BigitLength()) return -1;
if (a.BigitLength() > c.BigitLength()) return +1;
// The exponent encodes 0-bigits. So if there are more 0-digits in 'a' than
// 'b' has digits, then the bigit-length of 'a'+'b' must be equal to the one
// of 'a'.
if (a.exponent_ >= b.BigitLength() && a.BigitLength() < c.BigitLength()) {
return -1;
}
Chunk borrow = 0;
// Starting at min_exponent all digits are == 0. So no need to compare them.
int min_exponent = Min(Min(a.exponent_, b.exponent_), c.exponent_);
for (int i = c.BigitLength() - 1; i >= min_exponent; --i) {
Chunk chunk_a = a.BigitAt(i);
Chunk chunk_b = b.BigitAt(i);
Chunk chunk_c = c.BigitAt(i);
Chunk sum = chunk_a + chunk_b;
if (sum > chunk_c + borrow) {
return +1;
} else {
borrow = chunk_c + borrow - sum;
if (borrow > 1) return -1;
borrow <<= kBigitSize;
}
}
if (borrow == 0) return 0;
return -1;
}
void Bignum::Clamp() {
while (used_digits_ > 0 && bigits_[used_digits_ - 1] == 0) {
used_digits_--;
}
if (used_digits_ == 0) {
// Zero.
exponent_ = 0;
}
}
bool Bignum::IsClamped() const {
return used_digits_ == 0 || bigits_[used_digits_ - 1] != 0;
}
void Bignum::Zero() {
for (int i = 0; i < used_digits_; ++i) {
bigits_[i] = 0;
}
used_digits_ = 0;
exponent_ = 0;
}
void Bignum::Align(const Bignum& other) {
if (exponent_ > other.exponent_) {
// If "X" represents a "hidden" digit (by the exponent) then we are in the
// following case (a == this, b == other):
// a: aaaaaaXXXX or a: aaaaaXXX
// b: bbbbbbX b: bbbbbbbbXX
// We replace some of the hidden digits (X) of a with 0 digits.
// a: aaaaaa000X or a: aaaaa0XX
int zero_digits = exponent_ - other.exponent_;
EnsureCapacity(used_digits_ + zero_digits);
for (int i = used_digits_ - 1; i >= 0; --i) {
bigits_[i + zero_digits] = bigits_[i];
}
for (int i = 0; i < zero_digits; ++i) {
bigits_[i] = 0;
}
used_digits_ += zero_digits;
exponent_ -= zero_digits;
ASSERT(used_digits_ >= 0);
ASSERT(exponent_ >= 0);
}
}
void Bignum::BigitsShiftLeft(int shift_amount) {
ASSERT(shift_amount < kBigitSize);
ASSERT(shift_amount >= 0);
Chunk carry = 0;
for (int i = 0; i < used_digits_; ++i) {
Chunk new_carry = bigits_[i] >> (kBigitSize - shift_amount);
bigits_[i] = ((bigits_[i] << shift_amount) + carry) & kBigitMask;
carry = new_carry;
}
if (carry != 0) {
bigits_[used_digits_] = carry;
used_digits_++;
}
}
void Bignum::SubtractTimes(const Bignum& other, int factor) {
ASSERT(exponent_ <= other.exponent_);
if (factor < 3) {
for (int i = 0; i < factor; ++i) {
SubtractBignum(other);
}
return;
}
Chunk borrow = 0;
int exponent_diff = other.exponent_ - exponent_;
for (int i = 0; i < other.used_digits_; ++i) {
DoubleChunk product = static_cast<DoubleChunk>(factor) * other.bigits_[i];
DoubleChunk remove = borrow + product;
Chunk difference = bigits_[i + exponent_diff] - (remove & kBigitMask);
bigits_[i + exponent_diff] = difference & kBigitMask;
borrow = static_cast<Chunk>((difference >> (kChunkSize - 1)) +
(remove >> kBigitSize));
}
for (int i = other.used_digits_ + exponent_diff; i < used_digits_; ++i) {
if (borrow == 0) return;
Chunk difference = bigits_[i] - borrow;
bigits_[i] = difference & kBigitMask;
borrow = difference >> (kChunkSize - 1);
}
Clamp();
}
} // namespace double_conversion
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/bignum.h
================================================
// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef DOUBLE_CONVERSION_BIGNUM_H_
#define DOUBLE_CONVERSION_BIGNUM_H_
#include "utils.h"
namespace double_conversion {
class Bignum {
public:
// 3584 = 128 * 28. We can represent 2^3584 > 10^1000 accurately.
// This bignum can encode much bigger numbers, since it contains an
// exponent.
static const int kMaxSignificantBits = 3584;
Bignum();
void AssignUInt16(uint16_t value);
void AssignUInt64(uint64_t value);
void AssignBignum(const Bignum& other);
void AssignDecimalString(Vector<const char> value);
void AssignHexString(Vector<const char> value);
void AssignPowerUInt16(uint16_t base, int exponent);
void AddUInt16(uint16_t operand);
void AddUInt64(uint64_t operand);
void AddBignum(const Bignum& other);
// Precondition: this >= other.
void SubtractBignum(const Bignum& other);
void Square();
void ShiftLeft(int shift_amount);
void MultiplyByUInt32(uint32_t factor);
void MultiplyByUInt64(uint64_t factor);
void MultiplyByPowerOfTen(int exponent);
void Times10() { return MultiplyByUInt32(10); }
// Pseudocode:
// int result = this / other;
// this = this % other;
// In the worst case this function is in O(this/other).
uint16_t DivideModuloIntBignum(const Bignum& other);
bool ToHexString(char* buffer, int buffer_size) const;
// Returns
// -1 if a < b,
// 0 if a == b, and
// +1 if a > b.
static int Compare(const Bignum& a, const Bignum& b);
static bool Equal(const Bignum& a, const Bignum& b) {
return Compare(a, b) == 0;
}
static bool LessEqual(const Bignum& a, const Bignum& b) {
return Compare(a, b) <= 0;
}
static bool Less(const Bignum& a, const Bignum& b) {
return Compare(a, b) < 0;
}
// Returns Compare(a + b, c);
static int PlusCompare(const Bignum& a, const Bignum& b, const Bignum& c);
// Returns a + b == c
static bool PlusEqual(const Bignum& a, const Bignum& b, const Bignum& c) {
return PlusCompare(a, b, c) == 0;
}
// Returns a + b <= c
static bool PlusLessEqual(const Bignum& a, const Bignum& b, const Bignum& c) {
return PlusCompare(a, b, c) <= 0;
}
// Returns a + b < c
static bool PlusLess(const Bignum& a, const Bignum& b, const Bignum& c) {
return PlusCompare(a, b, c) < 0;
}
private:
typedef uint32_t Chunk;
typedef uint64_t DoubleChunk;
static const int kChunkSize = sizeof(Chunk) * 8;
static const int kDoubleChunkSize = sizeof(DoubleChunk) * 8;
// With bigit size of 28 we loose some bits, but a double still fits easily
// into two chunks, and more importantly we can use the Comba multiplication.
static const int kBigitSize = 28;
static const Chunk kBigitMask = (1 << kBigitSize) - 1;
// Every instance allocates kBigitLength chunks on the stack. Bignums cannot
// grow. There are no checks if the stack-allocated space is sufficient.
static const int kBigitCapacity = kMaxSignificantBits / kBigitSize;
void EnsureCapacity(int size) {
if (size > kBigitCapacity) {
UNREACHABLE();
}
}
void Align(const Bignum& other);
void Clamp();
bool IsClamped() const;
void Zero();
// Requires this to have enough capacity (no tests done).
// Updates used_digits_ if necessary.
// shift_amount must be < kBigitSize.
void BigitsShiftLeft(int shift_amount);
// BigitLength includes the "hidden" digits encoded in the exponent.
int BigitLength() const { return used_digits_ + exponent_; }
Chunk BigitAt(int index) const;
void SubtractTimes(const Bignum& other, int factor);
Chunk bigits_buffer_[kBigitCapacity];
// A vector backed by bigits_buffer_. This way accesses to the array are
// checked for out-of-bounds errors.
Vector<Chunk> bigits_;
int used_digits_;
// The Bignum's value equals value(bigits_) * 2^(exponent_ * kBigitSize).
int exponent_;
DISALLOW_COPY_AND_ASSIGN(Bignum);
};
} // namespace double_conversion
#endif // DOUBLE_CONVERSION_BIGNUM_H_
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/cached-powers.cc
================================================
// Copyright 2006-2008 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <stdarg.h>
#include <limits.h>
#include <math.h>
#include "utils.h"
#include "cached-powers.h"
namespace double_conversion {
struct CachedPower {
uint64_t significand;
int16_t binary_exponent;
int16_t decimal_exponent;
};
static const CachedPower kCachedPowers[] = {
{UINT64_2PART_C(0xfa8fd5a0, 081c0288), -1220, -348},
{UINT64_2PART_C(0xbaaee17f, a23ebf76), -1193, -340},
{UINT64_2PART_C(0x8b16fb20, 3055ac76), -1166, -332},
{UINT64_2PART_C(0xcf42894a, 5dce35ea), -1140, -324},
{UINT64_2PART_C(0x9a6bb0aa, 55653b2d), -1113, -316},
{UINT64_2PART_C(0xe61acf03, 3d1a45df), -1087, -308},
{UINT64_2PART_C(0xab70fe17, c79ac6ca), -1060, -300},
{UINT64_2PART_C(0xff77b1fc, bebcdc4f), -1034, -292},
{UINT64_2PART_C(0xbe5691ef, 416bd60c), -1007, -284},
{UINT64_2PART_C(0x8dd01fad, 907ffc3c), -980, -276},
{UINT64_2PART_C(0xd3515c28, 31559a83), -954, -268},
{UINT64_2PART_C(0x9d71ac8f, ada6c9b5), -927, -260},
{UINT64_2PART_C(0xea9c2277, 23ee8bcb), -901, -252},
{UINT64_2PART_C(0xaecc4991, 4078536d), -874, -244},
{UINT64_2PART_C(0x823c1279, 5db6ce57), -847, -236},
{UINT64_2PART_C(0xc2109436, 4dfb5637), -821, -228},
{UINT64_2PART_C(0x9096ea6f, 3848984f), -794, -220},
{UINT64_2PART_C(0xd77485cb, 25823ac7), -768, -212},
{UINT64_2PART_C(0xa086cfcd, 97bf97f4), -741, -204},
{UINT64_2PART_C(0xef340a98, 172aace5), -715, -196},
{UINT64_2PART_C(0xb23867fb, 2a35b28e), -688, -188},
{UINT64_2PART_C(0x84c8d4df, d2c63f3b), -661, -180},
{UINT64_2PART_C(0xc5dd4427, 1ad3cdba), -635, -172},
{UINT64_2PART_C(0x936b9fce, bb25c996), -608, -164},
{UINT64_2PART_C(0xdbac6c24, 7d62a584), -582, -156},
{UINT64_2PART_C(0xa3ab6658, 0d5fdaf6), -555, -148},
{UINT64_2PART_C(0xf3e2f893, dec3f126), -529, -140},
{UINT64_2PART_C(0xb5b5ada8, aaff80b8), -502, -132},
{UINT64_2PART_C(0x87625f05, 6c7c4a8b), -475, -124},
{UINT64_2PART_C(0xc9bcff60, 34c13053), -449, -116},
{UINT64_2PART_C(0x964e858c, 91ba2655), -422, -108},
{UINT64_2PART_C(0xdff97724, 70297ebd), -396, -100},
{UINT64_2PART_C(0xa6dfbd9f, b8e5b88f), -369, -92},
{UINT64_2PART_C(0xf8a95fcf, 88747d94), -343, -84},
{UINT64_2PART_C(0xb9447093, 8fa89bcf), -316, -76},
{UINT64_2PART_C(0x8a08f0f8, bf0f156b), -289, -68},
{UINT64_2PART_C(0xcdb02555, 653131b6), -263, -60},
{UINT64_2PART_C(0x993fe2c6, d07b7fac), -236, -52},
{UINT64_2PART_C(0xe45c10c4, 2a2b3b06), -210, -44},
{UINT64_2PART_C(0xaa242499, 697392d3), -183, -36},
{UINT64_2PART_C(0xfd87b5f2, 8300ca0e), -157, -28},
{UINT64_2PART_C(0xbce50864, 92111aeb), -130, -20},
{UINT64_2PART_C(0x8cbccc09, 6f5088cc), -103, -12},
{UINT64_2PART_C(0xd1b71758, e219652c), -77, -4},
{UINT64_2PART_C(0x9c400000, 00000000), -50, 4},
{UINT64_2PART_C(0xe8d4a510, 00000000), -24, 12},
{UINT64_2PART_C(0xad78ebc5, ac620000), 3, 20},
{UINT64_2PART_C(0x813f3978, f8940984), 30, 28},
{UINT64_2PART_C(0xc097ce7b, c90715b3), 56, 36},
{UINT64_2PART_C(0x8f7e32ce, 7bea5c70), 83, 44},
{UINT64_2PART_C(0xd5d238a4, abe98068), 109, 52},
{UINT64_2PART_C(0x9f4f2726, 179a2245), 136, 60},
{UINT64_2PART_C(0xed63a231, d4c4fb27), 162, 68},
{UINT64_2PART_C(0xb0de6538, 8cc8ada8), 189, 76},
{UINT64_2PART_C(0x83c7088e, 1aab65db), 216, 84},
{UINT64_2PART_C(0xc45d1df9, 42711d9a), 242, 92},
{UINT64_2PART_C(0x924d692c, a61be758), 269, 100},
{UINT64_2PART_C(0xda01ee64, 1a708dea), 295, 108},
{UINT64_2PART_C(0xa26da399, 9aef774a), 322, 116},
{UINT64_2PART_C(0xf209787b, b47d6b85), 348, 124},
{UINT64_2PART_C(0xb454e4a1, 79dd1877), 375, 132},
{UINT64_2PART_C(0x865b8692, 5b9bc5c2), 402, 140},
{UINT64_2PART_C(0xc83553c5, c8965d3d), 428, 148},
{UINT64_2PART_C(0x952ab45c, fa97a0b3), 455, 156},
{UINT64_2PART_C(0xde469fbd, 99a05fe3), 481, 164},
{UINT64_2PART_C(0xa59bc234, db398c25), 508, 172},
{UINT64_2PART_C(0xf6c69a72, a3989f5c), 534, 180},
{UINT64_2PART_C(0xb7dcbf53, 54e9bece), 561, 188},
{UINT64_2PART_C(0x88fcf317, f22241e2), 588, 196},
{UINT64_2PART_C(0xcc20ce9b, d35c78a5), 614, 204},
{UINT64_2PART_C(0x98165af3, 7b2153df), 641, 212},
{UINT64_2PART_C(0xe2a0b5dc, 971f303a), 667, 220},
{UINT64_2PART_C(0xa8d9d153, 5ce3b396), 694, 228},
{UINT64_2PART_C(0xfb9b7cd9, a4a7443c), 720, 236},
{UINT64_2PART_C(0xbb764c4c, a7a44410), 747, 244},
{UINT64_2PART_C(0x8bab8eef, b6409c1a), 774, 252},
{UINT64_2PART_C(0xd01fef10, a657842c), 800, 260},
{UINT64_2PART_C(0x9b10a4e5, e9913129), 827, 268},
{UINT64_2PART_C(0xe7109bfb, a19c0c9d), 853, 276},
{UINT64_2PART_C(0xac2820d9, 623bf429), 880, 284},
{UINT64_2PART_C(0x80444b5e, 7aa7cf85), 907, 292},
{UINT64_2PART_C(0xbf21e440, 03acdd2d), 933, 300},
{UINT64_2PART_C(0x8e679c2f, 5e44ff8f), 960, 308},
{UINT64_2PART_C(0xd433179d, 9c8cb841), 986, 316},
{UINT64_2PART_C(0x9e19db92, b4e31ba9), 1013, 324},
{UINT64_2PART_C(0xeb96bf6e, badf77d9), 1039, 332},
{UINT64_2PART_C(0xaf87023b, 9bf0ee6b), 1066, 340},
};
static const int kCachedPowersLength = ARRAY_SIZE(kCachedPowers);
static const int kCachedPowersOffset = 348; // -1 * the first decimal_exponent.
static const double kD_1_LOG2_10 = 0.30102999566398114; // 1 / lg(10)
// Difference between the decimal exponents in the table above.
const int PowersOfTenCache::kDecimalExponentDistance = 8;
const int PowersOfTenCache::kMinDecimalExponent = -348;
const int PowersOfTenCache::kMaxDecimalExponent = 340;
void PowersOfTenCache::GetCachedPowerForBinaryExponentRange(
int min_exponent,
int max_exponent,
DiyFp* power,
int* decimal_exponent) {
int kQ = DiyFp::kSignificandSize;
double k = ceil((min_exponent + kQ - 1) * kD_1_LOG2_10);
int foo = kCachedPowersOffset;
int index =
(foo + static_cast<int>(k) - 1) / kDecimalExponentDistance + 1;
ASSERT(0 <= index && index < kCachedPowersLength);
CachedPower cached_power = kCachedPowers[index];
ASSERT(min_exponent <= cached_power.binary_exponent);
(void) max_exponent; // Mark variable as used.
ASSERT(cached_power.binary_exponent <= max_exponent);
*decimal_exponent = cached_power.decimal_exponent;
*power = DiyFp(cached_power.significand, cached_power.binary_exponent);
}
void PowersOfTenCache::GetCachedPowerForDecimalExponent(int requested_exponent,
DiyFp* power,
int* found_exponent) {
ASSERT(kMinDecimalExponent <= requested_exponent);
ASSERT(requested_exponent < kMaxDecimalExponent + kDecimalExponentDistance);
int index =
(requested_exponent + kCachedPowersOffset) / kDecimalExponentDistance;
CachedPower cached_power = kCachedPowers[index];
*power = DiyFp(cached_power.significand, cached_power.binary_exponent);
*found_exponent = cached_power.decimal_exponent;
ASSERT(*found_exponent <= requested_exponent);
ASSERT(requested_exponent < *found_exponent + kDecimalExponentDistance);
}
} // namespace double_conversion
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/cached-powers.h
================================================
// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef DOUBLE_CONVERSION_CACHED_POWERS_H_
#define DOUBLE_CONVERSION_CACHED_POWERS_H_
#include "diy-fp.h"
namespace double_conversion {
class PowersOfTenCache {
public:
// Not all powers of ten are cached. The decimal exponent of two neighboring
// cached numbers will differ by kDecimalExponentDistance.
static const int kDecimalExponentDistance;
static const int kMinDecimalExponent;
static const int kMaxDecimalExponent;
// Returns a cached power-of-ten with a binary exponent in the range
// [min_exponent; max_exponent] (boundaries included).
static void GetCachedPowerForBinaryExponentRange(int min_exponent,
int max_exponent,
DiyFp* power,
int* decimal_exponent);
// Returns a cached power of ten x ~= 10^k such that
// k <= decimal_exponent < k + kCachedPowersDecimalDistance.
// The given decimal_exponent must satisfy
// kMinDecimalExponent <= requested_exponent, and
// requested_exponent < kMaxDecimalExponent + kDecimalExponentDistance.
static void GetCachedPowerForDecimalExponent(int requested_exponent,
DiyFp* power,
int* found_exponent);
};
} // namespace double_conversion
#endif // DOUBLE_CONVERSION_CACHED_POWERS_H_
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/diy-fp.cc
================================================
// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "diy-fp.h"
#include "utils.h"
namespace double_conversion {
void DiyFp::Multiply(const DiyFp& other) {
// Simply "emulates" a 128 bit multiplication.
// However: the resulting number only contains 64 bits. The least
// significant 64 bits are only used for rounding the most significant 64
// bits.
const uint64_t kM32 = 0xFFFFFFFFU;
uint64_t a = f_ >> 32;
uint64_t b = f_ & kM32;
uint64_t c = other.f_ >> 32;
uint64_t d = other.f_ & kM32;
uint64_t ac = a * c;
uint64_t bc = b * c;
uint64_t ad = a * d;
uint64_t bd = b * d;
uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32);
// By adding 1U << 31 to tmp we round the final result.
// Halfway cases will be round up.
tmp += 1U << 31;
uint64_t result_f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
e_ += other.e_ + 64;
f_ = result_f;
}
} // namespace double_conversion
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/diy-fp.h
================================================
// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef DOUBLE_CONVERSION_DIY_FP_H_
#define DOUBLE_CONVERSION_DIY_FP_H_
#include "utils.h"
namespace double_conversion {
// This "Do It Yourself Floating Point" class implements a floating-point number
// with a uint64 significand and an int exponent. Normalized DiyFp numbers will
// have the most significant bit of the significand set.
// Multiplication and Subtraction do not normalize their results.
// DiyFp are not designed to contain special doubles (NaN and Infinity).
class DiyFp {
public:
static const int kSignificandSize = 64;
DiyFp() : f_(0), e_(0) {}
DiyFp(uint64_t f, int e) : f_(f), e_(e) {}
// this = this - other.
// The exponents of both numbers must be the same and the significand of this
// must be bigger than the significand of other.
// The result will not be normalized.
void Subtract(const DiyFp& other) {
ASSERT(e_ == other.e_);
ASSERT(f_ >= other.f_);
f_ -= other.f_;
}
// Returns a - b.
// The exponents of both numbers must be the same and this must be bigger
// than other. The result will not be normalized.
static DiyFp Minus(const DiyFp& a, const DiyFp& b) {
DiyFp result = a;
result.Subtract(b);
return result;
}
// this = this * other.
void Multiply(const DiyFp& other);
// returns a * b;
static DiyFp Times(const DiyFp& a, const DiyFp& b) {
DiyFp result = a;
result.Multiply(b);
return result;
}
void Normalize() {
ASSERT(f_ != 0);
uint64_t f = f_;
int e = e_;
// This method is mainly called for normalizing boundaries. In general
// boundaries need to be shifted by 10 bits. We thus optimize for this case.
const uint64_t k10MSBits = UINT64_2PART_C(0xFFC00000, 00000000);
while ((f & k10MSBits) == 0) {
f <<= 10;
e -= 10;
}
while ((f & kUint64MSB) == 0) {
f <<= 1;
e--;
}
f_ = f;
e_ = e;
}
static DiyFp Normalize(const DiyFp& a) {
DiyFp result = a;
result.Normalize();
return result;
}
uint64_t f() const { return f_; }
int e() const { return e_; }
void set_f(uint64_t new_value) { f_ = new_value; }
void set_e(int new_value) { e_ = new_value; }
private:
static const uint64_t kUint64MSB = UINT64_2PART_C(0x80000000, 00000000);
uint64_t f_;
int e_;
};
} // namespace double_conversion
#endif // DOUBLE_CONVERSION_DIY_FP_H_
================================================
FILE: example/ios/Pods/DoubleConversion/double-conversion/double-conversion.cc
================================================
// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <limits.h>
#include <math.h>
#include "double-conversion.h"
#include "bignum-dtoa.h"
#include "fast-dtoa.h"
#include "fixed-dtoa.h"
#include "ieee.h"
#include "strtod.h"
#include "utils.h"
namespace double_conversion {
const DoubleToStringConverter& DoubleToStringConverter::EcmaScriptConverter() {
int flags = UNIQUE_ZERO | EMIT_POSITIVE_EXPONENT_SIGN;
static DoubleToStringConverter converter(flags,
"Infinity",
"NaN",
'e',
-6, 21,
6, 0);
return converter;
}
bool DoubleToStringConverter::HandleSpecialValues(
double value,
StringBuilder* result_builder) const {
Double double_inspect(value);
if (double_inspect.IsInfinite()) {
if (infinity_symbol_ == NULL) return false;
if (value < 0) {
result_builder->AddCharacter('-');
}
result_builder->AddString(infinity_symbol_);
return true;
}
if (double_inspect.IsNan()) {
if (nan_symbol_ == NULL) return false;
result_builder->AddString(nan_symbol_);
return true;
}
return false;
}
void DoubleToStringConverter::CreateExponentialRepresentation(
const char* decimal_digits,
int length,
int exponent,
StringBuilder* result_builder) const {
ASSERT(length != 0);
result_builder->AddCharacter(decimal_digits[0]);
if (length != 1) {
result_builder->AddCharacter('.');
result_builder->AddSubstring(&decimal_digits[1], length-1);
}
result_builder->AddCharacter(exponent_character_);
if (exponent < 0) {
result_builder->AddCharacter('-');
exponent = -exponent;
} else {
if ((flags_ & EMIT_POSITIVE_EXPONENT_SIGN) != 0) {
result_builder->AddCharacter('+');
}
}
if (exponent == 0) {
result_builder->AddCharacter('0');
return;
}
ASSERT(exponent < 1e4);
const int kMaxExponentLength = 5;
char buffer[kMaxExponentLength + 1];
buffer[kMaxExponentLength] = '\0';
int first_char_pos = kMaxExponentLength;
while (exponent > 0) {
buffer[--first_char_pos] = '0' + (exponent % 10);
exponent /= 10;
}
result_builder->AddSubstring(&buffer[first_char_pos],
kMaxExponentLength - first_char_pos);
}
void DoubleToStringConverter::CreateDecimalRepresentation(
const char* decimal_digits,
int length,
int decimal_point,
int digits_after_point,
StringBuilder* result_builder) const {
// Create a representation that is padded with zeros if needed.
if (decimal_point <= 0) {
// "0.00000decimal_rep".
result_builder->AddCharacter('0');
if (digits_after_point > 0) {
result_builder->AddCharacter('.');
result_builder->AddPadding('0', -decimal_point);
ASSERT(length <= digits_after_point - (-decimal_point));
result_builder->AddSubstring(decimal_digits, length);
int remaining_digits = digits_after_point - (-decimal_point) - length;
result_builder->AddPadding('0', remaining_digits);
}
} else if (decimal_point >= length) {
// "decimal_rep0000.00000" or "decimal_rep.0000"
result_builder->AddSubstring(decimal_digits, length);
result_builder->AddPadding('0', decimal_point - length);
if (digits_after_point > 0) {
result_builder->AddCharacter('.');
result_builder->AddPadding('0', digits_after_point);
}
} else {
// "decima.l_rep000"
ASSERT(digits_after_point > 0);
result_builder->AddSubstring(decimal_digits, decimal_point);
result_builder->AddCharacter('.');
ASSERT(length - decimal_point <= digits_after_point);
result_builder->AddSubstring(&decimal_digits[decimal_point],
length - decimal_point);
int remaining_digits = digits_after_point - (length - decimal_point);
result_builder->AddPadding('0', remaining_digits);
}
if (digits_after_point == 0) {
if ((flags_ & EMIT_TRAILING_DECIMAL_POINT) != 0) {
result_builder->AddCharacter('.');
}
if ((flags_ & EMIT_TRAILING_ZERO_AFTER_POINT) != 0) {
result_builder->AddCharacter('0');
}
}
}
bool DoubleToStringConverter::ToShortestIeeeNumber(
double value,
StringBuilder* result_builder,
DoubleToStringConverter::DtoaMode mode) const {
ASSERT(mode == SHORTEST || mode == SHORTEST_SINGLE);
if (Double(value).IsSpecial()) {
return HandleSpecialValues(value, result_builder);
}
int decimal_point;
bool sign;
const int kDecimalRepCapacity = kBase10MaximalLength + 1;
char decimal_rep[kDecimalRepCapacity];
int decimal_rep_length;
DoubleToAscii(value, mode, 0, decimal_rep, kDecimalRepCapacity,
&sign, &decimal_rep_length, &decimal_point);
bool unique_zero = (flags_ & UNIQUE_ZERO) != 0;
if (sign && (value != 0.0 || !unique_zero)) {
result_builder->AddCharacter('-');
}
int exponent = decimal_point - 1;
if ((decimal_in_shortest_low_ <= exponent) &&
(exponent < decimal_in_shortest_high_)) {
CreateDecimalRepresentation(decimal_rep, decimal_rep_length,
decimal_point,
Max(0, decimal_rep_length - decimal_point),
result_builder);
} else {
CreateExponentialRepresentation(decimal_rep, decimal_rep_length, exponent,
result_builder);
}
return true;
}
bool DoubleToStringConverter::ToFixed(double value,
int requested_digits,
StringBuilder* result_builder) const {
ASSERT(kMaxFixedDigitsBeforePoint == 60);
const double kFirstNonFixed = 1e60;
if (Double(value).IsSpecial()) {
return HandleSpecialValues(value, result_builder);
}
if (requested_digits > kMaxFixedDigitsAfterPoint) return false;
if (value >= kFirstNonFixed || value <= -kFirstNonFixed) return false;
// Find a sufficiently precise decimal representation of n.
int decimal_point;
bool sign;
// Add space for the '\0' byte.
const int kDecimalRepCapacity =
kMaxFixedDigitsBeforePoint + kMaxFixedDigitsAfterPoint + 1;
char decimal_rep[kDecimalRepCapacity];
int decimal_rep_length;
DoubleToAscii(value, FIXED, requested_digits,
decimal_rep, kDecimalRepCapacity,
&sign, &decimal_rep_length, &decimal_point);
bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
if (sign && (value != 0.0 || !unique_zero)) {
result_builde
Showing preview only (981K chars total). Download the full file or copy to clipboard to get everything.
gitextract_f_9f_4qy/ ├── .gitignore ├── .npmignore ├── CONTRIBUTING.md ├── LICENSE ├── README.md ├── android/ │ ├── build.gradle │ ├── gradle.properties │ └── src/ │ └── main/ │ ├── AndroidManifest.xml │ └── java/ │ └── com/ │ └── reactnativereceivesharingintent/ │ ├── FileDirectory.kt │ ├── ReceiveSharingIntentHelper.java │ ├── ReceiveSharingIntentModule.java │ └── ReceiveSharingIntentPackage.kt ├── babel.config.js ├── docs/ │ ├── .gitignore │ ├── README.md │ ├── babel.config.js │ ├── docs/ │ │ ├── android.md │ │ ├── author.md │ │ ├── demo.md │ │ ├── donate.md │ │ ├── intro.md │ │ └── ios.md │ ├── docusaurus.config.js │ ├── package.json │ ├── sidebars.js │ ├── src/ │ │ ├── components/ │ │ │ ├── HomepageFeatures.js │ │ │ └── HomepageFeatures.module.css │ │ ├── css/ │ │ │ └── custom.css │ │ ├── pages/ │ │ │ ├── index.js │ │ │ ├── index.module.css │ │ │ └── markdown-page.md │ │ └── theme/ │ │ └── Footer/ │ │ ├── index.tsx │ │ └── styles.module.css │ ├── static/ │ │ └── .nojekyll │ └── tsconfig.json ├── example/ │ ├── android/ │ │ ├── app/ │ │ │ ├── build.gradle │ │ │ ├── proguard-rules.pro │ │ │ └── src/ │ │ │ ├── debug/ │ │ │ │ ├── AndroidManifest.xml │ │ │ │ └── java/ │ │ │ │ └── com/ │ │ │ │ └── example/ │ │ │ │ └── reactnativereceivesharingintent/ │ │ │ │ └── ReactNativeFlipper.java │ │ │ └── main/ │ │ │ ├── AndroidManifest.xml │ │ │ ├── java/ │ │ │ │ └── com/ │ │ │ │ └── example/ │ │ │ │ └── reactnativereceivesharingintent/ │ │ │ │ ├── MainActivity.java │ │ │ │ └── MainApplication.java │ │ │ └── res/ │ │ │ └── values/ │ │ │ ├── strings.xml │ │ │ └── styles.xml │ │ ├── build.gradle │ │ ├── gradle/ │ │ │ └── wrapper/ │ │ │ ├── gradle-wrapper.jar │ │ │ └── gradle-wrapper.properties │ │ ├── gradle.properties │ │ ├── gradlew │ │ ├── gradlew.bat │ │ └── settings.gradle │ ├── app.json │ ├── babel.config.js │ ├── index.tsx │ ├── ios/ │ │ ├── File.swift │ │ ├── Podfile │ │ ├── Pods/ │ │ │ ├── DoubleConversion/ │ │ │ │ ├── LICENSE │ │ │ │ ├── README │ │ │ │ └── double-conversion/ │ │ │ │ ├── bignum-dtoa.cc │ │ │ │ ├── bignum-dtoa.h │ │ │ │ ├── bignum.cc │ │ │ │ ├── bignum.h │ │ │ │ ├── cached-powers.cc │ │ │ │ ├── cached-powers.h │ │ │ │ ├── diy-fp.cc │ │ │ │ ├── diy-fp.h │ │ │ │ ├── double-conversion.cc │ │ │ │ ├── double-conversion.h │ │ │ │ ├── fast-dtoa.cc │ │ │ │ ├── fast-dtoa.h │ │ │ │ ├── fixed-dtoa.cc │ │ │ │ ├── fixed-dtoa.h │ │ │ │ ├── ieee.h │ │ │ │ ├── strtod.cc │ │ │ │ ├── strtod.h │ │ │ │ └── utils.h │ │ │ ├── Folly/ │ │ │ │ ├── LICENSE │ │ │ │ ├── README.md │ │ │ │ └── folly/ │ │ │ │ ├── AtomicHashArray-inl.h │ │ │ │ ├── AtomicHashArray.h │ │ │ │ ├── AtomicHashMap-inl.h │ │ │ │ ├── AtomicHashMap.h │ │ │ │ ├── AtomicIntrusiveLinkedList.h │ │ │ │ ├── AtomicLinkedList.h │ │ │ │ ├── AtomicUnorderedMap.h │ │ │ │ ├── Benchmark.h │ │ │ │ ├── Bits.h │ │ │ │ ├── CPortability.h │ │ │ │ ├── CachelinePadded.h │ │ │ │ ├── CancellationToken-inl.h │ │ │ │ ├── CancellationToken.h │ │ │ │ ├── Chrono.h │ │ │ │ ├── ClockGettimeWrappers.h │ │ │ │ ├── ConcurrentBitSet.h │ │ │ │ ├── ConcurrentSkipList-inl.h │ │ │ │ ├── ConcurrentSkipList.h │ │ │ │ ├── ConstexprMath.h │ │ │ │ ├── Conv.cpp │ │ │ │ ├── Conv.h │ │ │ │ ├── CppAttributes.h │ │ │ │ ├── CpuId.h │ │ │ │ ├── DefaultKeepAliveExecutor.h │ │ │ │ ├── Demangle.cpp │ │ │ │ ├── Demangle.h │ │ │ │ ├── DiscriminatedPtr.h │ │ │ │ ├── DynamicConverter.h │ │ │ │ ├── Exception.h │ │ │ │ ├── ExceptionString.h │ │ │ │ ├── ExceptionWrapper-inl.h │ │ │ │ ├── ExceptionWrapper.h │ │ │ │ ├── Executor.h │ │ │ │ ├── Expected.h │ │ │ │ ├── FBString.h │ │ │ │ ├── FBVector.h │ │ │ │ ├── File.h │ │ │ │ ├── FileUtil.cpp │ │ │ │ ├── FileUtil.h │ │ │ │ ├── Fingerprint.h │ │ │ │ ├── FixedString.h │ │ │ │ ├── Format-inl.h │ │ │ │ ├── Format.cpp │ │ │ │ ├── Format.h │ │ │ │ ├── FormatArg.h │ │ │ │ ├── FormatTraits.h │ │ │ │ ├── Function.h │ │ │ │ ├── GLog.h │ │ │ │ ├── GroupVarint.h │ │ │ │ ├── Hash.h │ │ │ │ ├── IPAddress.h │ │ │ │ ├── IPAddressException.h │ │ │ │ ├── IPAddressV4.h │ │ │ │ ├── IPAddressV6.h │ │ │ │ ├── Indestructible.h │ │ │ │ ├── IndexedMemPool.h │ │ │ │ ├── IntrusiveList.h │ │ │ │ ├── Lazy.h │ │ │ │ ├── Likely.h │ │ │ │ ├── LockTraits.h │ │ │ │ ├── MPMCPipeline.h │ │ │ │ ├── MPMCQueue.h │ │ │ │ ├── MacAddress.h │ │ │ │ ├── MapUtil.h │ │ │ │ ├── Math.h │ │ │ │ ├── Memory.h │ │ │ │ ├── MicroLock.h │ │ │ │ ├── MicroSpinLock.h │ │ │ │ ├── MoveWrapper.h │ │ │ │ ├── Optional.h │ │ │ │ ├── Overload.h │ │ │ │ ├── PackedSyncPtr.h │ │ │ │ ├── Padded.h │ │ │ │ ├── Poly-inl.h │ │ │ │ ├── Poly.h │ │ │ │ ├── PolyException.h │ │ │ │ ├── Portability.h │ │ │ │ ├── Preprocessor.h │ │ │ │ ├── ProducerConsumerQueue.h │ │ │ │ ├── RWSpinLock.h │ │ │ │ ├── Random-inl.h │ │ │ │ ├── Random.h │ │ │ │ ├── Range.h │ │ │ │ ├── Replaceable.h │ │ │ │ ├── ScopeGuard.cpp │ │ │ │ ├── ScopeGuard.h │ │ │ │ ├── SharedMutex.h │ │ │ │ ├── Singleton-inl.h │ │ │ │ ├── Singleton.h │ │ │ │ ├── SingletonThreadLocal.h │ │ │ │ ├── SocketAddress.h │ │ │ │ ├── SpinLock.h │ │ │ │ ├── String-inl.h │ │ │ │ ├── String.cpp │ │ │ │ ├── String.h │ │ │ │ ├── Subprocess.h │ │ │ │ ├── Synchronized.h │ │ │ │ ├── SynchronizedPtr.h │ │ │ │ ├── ThreadCachedInt.h │ │ │ │ ├── ThreadLocal.h │ │ │ │ ├── TimeoutQueue.h │ │ │ │ ├── TokenBucket.h │ │ │ │ ├── Traits.h │ │ │ │ ├── Try-inl.h │ │ │ │ ├── Try.h │ │ │ │ ├── UTF8String.h │ │ │ │ ├── Unicode.cpp │ │ │ │ ├── Unicode.h │ │ │ │ ├── Unit.h │ │ │ │ ├── Uri-inl.h │ │ │ │ ├── Uri.h │ │ │ │ ├── Utility.h │ │ │ │ ├── Varint.h │ │ │ │ ├── VirtualExecutor.h │ │ │ │ ├── container/ │ │ │ │ │ ├── Access.h │ │ │ │ │ ├── Array.h │ │ │ │ │ ├── BitIterator.h │ │ │ │ │ ├── Enumerate.h │ │ │ │ │ ├── EvictingCacheMap.h │ │ │ │ │ ├── F14Map-fwd.h │ │ │ │ │ ├── F14Map.h │ │ │ │ │ ├── F14Set-fwd.h │ │ │ │ │ ├── F14Set.h │ │ │ │ │ ├── Foreach-inl.h │ │ │ │ │ ├── Foreach.h │ │ │ │ │ ├── HeterogeneousAccess-fwd.h │ │ │ │ │ ├── HeterogeneousAccess.h │ │ │ │ │ ├── Iterator.h │ │ │ │ │ ├── Merge.h │ │ │ │ │ ├── SparseByteSet.h │ │ │ │ │ └── detail/ │ │ │ │ │ ├── BitIteratorDetail.h │ │ │ │ │ ├── F14Defaults.h │ │ │ │ │ ├── F14IntrinsicsAvailability.h │ │ │ │ │ ├── F14Mask.h │ │ │ │ │ ├── F14Policy.h │ │ │ │ │ ├── F14Table.cpp │ │ │ │ │ ├── F14Table.h │ │ │ │ │ └── Util.h │ │ │ │ ├── detail/ │ │ │ │ │ ├── AsyncTrace.h │ │ │ │ │ ├── AtFork.h │ │ │ │ │ ├── AtomicHashUtils.h │ │ │ │ │ ├── AtomicUnorderedMapUtils.h │ │ │ │ │ ├── Demangle.cpp │ │ │ │ │ ├── Demangle.h │ │ │ │ │ ├── DiscriminatedPtrDetail.h │ │ │ │ │ ├── FileUtilDetail.h │ │ │ │ │ ├── FingerprintPolynomial.h │ │ │ │ │ ├── Futex-inl.h │ │ │ │ │ ├── Futex.h │ │ │ │ │ ├── GroupVarintDetail.h │ │ │ │ │ ├── IPAddress.h │ │ │ │ │ ├── IPAddressSource.h │ │ │ │ │ ├── Iterators.h │ │ │ │ │ ├── MPMCPipelineDetail.h │ │ │ │ │ ├── MemoryIdler.h │ │ │ │ │ ├── PolyDetail.h │ │ │ │ │ ├── RangeCommon.h │ │ │ │ │ ├── RangeSse42.h │ │ │ │ │ ├── Singleton.h │ │ │ │ │ ├── SingletonStackTrace.h │ │ │ │ │ ├── SlowFingerprint.h │ │ │ │ │ ├── SocketFastOpen.h │ │ │ │ │ ├── Sse.h │ │ │ │ │ ├── StaticSingletonManager.h │ │ │ │ │ ├── ThreadLocalDetail.h │ │ │ │ │ ├── TurnSequencer.h │ │ │ │ │ ├── TypeList.h │ │ │ │ │ ├── UniqueInstance.cpp │ │ │ │ │ └── UniqueInstance.h │ │ │ │ ├── dynamic-inl.h │ │ │ │ ├── dynamic.cpp │ │ │ │ ├── dynamic.h │ │ │ │ ├── functional/ │ │ │ │ │ ├── ApplyTuple.h │ │ │ │ │ ├── Invoke.h │ │ │ │ │ └── Partial.h │ │ │ │ ├── hash/ │ │ │ │ │ ├── Checksum.h │ │ │ │ │ ├── FarmHash.h │ │ │ │ │ ├── Hash.h │ │ │ │ │ ├── SpookyHashV1.h │ │ │ │ │ ├── SpookyHashV2.cpp │ │ │ │ │ └── SpookyHashV2.h │ │ │ │ ├── json.cpp │ │ │ │ ├── json.h │ │ │ │ ├── json_patch.h │ │ │ │ ├── json_pointer.cpp │ │ │ │ ├── json_pointer.h │ │ │ │ ├── lang/ │ │ │ │ │ ├── Align.h │ │ │ │ │ ├── Aligned.h │ │ │ │ │ ├── Assume.cpp │ │ │ │ │ ├── Assume.h │ │ │ │ │ ├── Bits.h │ │ │ │ │ ├── CString.cpp │ │ │ │ │ ├── CString.h │ │ │ │ │ ├── Cast.h │ │ │ │ │ ├── CheckedMath.h │ │ │ │ │ ├── CustomizationPoint.h │ │ │ │ │ ├── Exception.h │ │ │ │ │ ├── Launder.h │ │ │ │ │ ├── Ordering.h │ │ │ │ │ ├── Pretty.h │ │ │ │ │ ├── PropagateConst.h │ │ │ │ │ ├── RValueReferenceWrapper.h │ │ │ │ │ ├── SafeAssert.cpp │ │ │ │ │ ├── SafeAssert.h │ │ │ │ │ ├── StaticConst.h │ │ │ │ │ ├── TypeInfo.h │ │ │ │ │ └── UncaughtExceptions.h │ │ │ │ ├── memory/ │ │ │ │ │ ├── Arena-inl.h │ │ │ │ │ ├── Arena.h │ │ │ │ │ ├── EnableSharedFromThis.h │ │ │ │ │ ├── MallctlHelper.h │ │ │ │ │ ├── Malloc.h │ │ │ │ │ ├── MemoryResource.h │ │ │ │ │ ├── SanitizeLeak.h │ │ │ │ │ ├── ThreadCachedArena.h │ │ │ │ │ ├── UninitializedMemoryHacks.h │ │ │ │ │ └── detail/ │ │ │ │ │ ├── MallocImpl.cpp │ │ │ │ │ └── MallocImpl.h │ │ │ │ ├── net/ │ │ │ │ │ ├── NetOps.cpp │ │ │ │ │ ├── NetOps.h │ │ │ │ │ ├── NetworkSocket.h │ │ │ │ │ └── detail/ │ │ │ │ │ └── SocketFileDescriptorMap.h │ │ │ │ ├── portability/ │ │ │ │ │ ├── Asm.h │ │ │ │ │ ├── Atomic.h │ │ │ │ │ ├── Builtins.h │ │ │ │ │ ├── Config.h │ │ │ │ │ ├── Constexpr.h │ │ │ │ │ ├── Dirent.h │ │ │ │ │ ├── Event.h │ │ │ │ │ ├── Fcntl.h │ │ │ │ │ ├── GFlags.h │ │ │ │ │ ├── GMock.h │ │ │ │ │ ├── GTest.h │ │ │ │ │ ├── IOVec.h │ │ │ │ │ ├── Libgen.h │ │ │ │ │ ├── Malloc.h │ │ │ │ │ ├── Math.h │ │ │ │ │ ├── Memory.h │ │ │ │ │ ├── OpenSSL.h │ │ │ │ │ ├── PThread.h │ │ │ │ │ ├── Sched.h │ │ │ │ │ ├── Semaphore.h │ │ │ │ │ ├── Sockets.h │ │ │ │ │ ├── Stdio.h │ │ │ │ │ ├── Stdlib.h │ │ │ │ │ ├── String.h │ │ │ │ │ ├── SysFile.h │ │ │ │ │ ├── SysMembarrier.h │ │ │ │ │ ├── SysMman.h │ │ │ │ │ ├── SysResource.h │ │ │ │ │ ├── SysStat.h │ │ │ │ │ ├── SysSyscall.h │ │ │ │ │ ├── SysTime.h │ │ │ │ │ ├── SysTypes.h │ │ │ │ │ ├── SysUio.cpp │ │ │ │ │ ├── SysUio.h │ │ │ │ │ ├── Syslog.h │ │ │ │ │ ├── Time.h │ │ │ │ │ ├── Unistd.h │ │ │ │ │ └── Windows.h │ │ │ │ ├── small_vector.h │ │ │ │ ├── sorted_vector_types.h │ │ │ │ └── stop_watch.h │ │ │ ├── Local Podspecs/ │ │ │ │ ├── DoubleConversion.podspec.json │ │ │ │ ├── FBLazyVector.podspec.json │ │ │ │ ├── FBReactNativeSpec.podspec.json │ │ │ │ ├── Folly.podspec.json │ │ │ │ ├── RCTRequired.podspec.json │ │ │ │ ├── RCTTypeSafety.podspec.json │ │ │ │ ├── React-Core.podspec.json │ │ │ │ ├── React-CoreModules.podspec.json │ │ │ │ ├── React-RCTActionSheet.podspec.json │ │ │ │ ├── React-RCTAnimation.podspec.json │ │ │ │ ├── React-RCTBlob.podspec.json │ │ │ │ ├── React-RCTImage.podspec.json │ │ │ │ ├── React-RCTLinking.podspec.json │ │ │ │ ├── React-RCTNetwork.podspec.json │ │ │ │ ├── React-RCTSettings.podspec.json │ │ │ │ ├── React-RCTText.podspec.json │ │ │ │ ├── React-RCTVibration.podspec.json │ │ │ │ ├── React-callinvoker.podspec.json │ │ │ │ ├── React-cxxreact.podspec.json │ │ │ │ ├── React-jsi.podspec.json │ │ │ │ ├── React-jsiexecutor.podspec.json │ │ │ │ ├── React-jsinspector.podspec.json │ │ │ │ ├── React.podspec.json │ │ │ │ ├── ReactCommon.podspec.json │ │ │ │ ├── Yoga.podspec.json │ │ │ │ ├── glog.podspec.json │ │ │ │ └── react-native-receive-sharing-intent.podspec.json │ │ │ ├── Pods.xcodeproj/ │ │ │ │ └── project.pbxproj │ │ │ ├── Target Support Files/ │ │ │ │ ├── DoubleConversion/ │ │ │ │ │ ├── DoubleConversion-dummy.m │ │ │ │ │ ├── DoubleConversion-prefix.pch │ │ │ │ │ ├── DoubleConversion.debug.xcconfig │ │ │ │ │ └── DoubleConversion.release.xcconfig │ │ │ │ ├── FBLazyVector/ │ │ │ │ │ ├── FBLazyVector.debug.xcconfig │ │ │ │ │ └── FBLazyVector.release.xcconfig │ │ │ │ ├── FBReactNativeSpec/ │ │ │ │ │ ├── FBReactNativeSpec-dummy.m │ │ │ │ │ ├── FBReactNativeSpec-prefix.pch │ │ │ │ │ ├── FBReactNativeSpec.debug.xcconfig │ │ │ │ │ └── FBReactNativeSpec.release.xcconfig │ │ │ │ ├── Folly/ │ │ │ │ │ ├── Folly-dummy.m │ │ │ │ │ ├── Folly-prefix.pch │ │ │ │ │ ├── Folly.debug.xcconfig │ │ │ │ │ └── Folly.release.xcconfig │ │ │ │ ├── Pods-ReceiveSharingIntentExample/ │ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-acknowledgements.markdown │ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-acknowledgements.plist │ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-dummy.m │ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-resources.sh │ │ │ │ │ ├── Pods-ReceiveSharingIntentExample-umbrella.h │ │ │ │ │ ├── Pods-ReceiveSharingIntentExample.debug.xcconfig │ │ │ │ │ ├── Pods-ReceiveSharingIntentExample.modulemap │ │ │ │ │ └── Pods-ReceiveSharingIntentExample.release.xcconfig │ │ │ │ ├── RCTRequired/ │ │ │ │ │ ├── RCTRequired.debug.xcconfig │ │ │ │ │ └── RCTRequired.release.xcconfig │ │ │ │ ├── RCTTypeSafety/ │ │ │ │ │ ├── RCTTypeSafety-dummy.m │ │ │ │ │ ├── RCTTypeSafety-prefix.pch │ │ │ │ │ ├── RCTTypeSafety.debug.xcconfig │ │ │ │ │ └── RCTTypeSafety.release.xcconfig │ │ │ │ ├── React/ │ │ │ │ │ ├── React.debug.xcconfig │ │ │ │ │ └── React.release.xcconfig │ │ │ │ ├── React-Core/ │ │ │ │ │ ├── React-Core-dummy.m │ │ │ │ │ ├── React-Core-prefix.pch │ │ │ │ │ ├── React-Core-umbrella.h │ │ │ │ │ ├── React-Core.debug.xcconfig │ │ │ │ │ ├── React-Core.modulemap │ │ │ │ │ ├── React-Core.release.xcconfig │ │ │ │ │ └── ResourceBundle-AccessibilityResources-React-Core-Info.plist │ │ │ │ ├── React-CoreModules/ │ │ │ │ │ ├── React-CoreModules-dummy.m │ │ │ │ │ ├── React-CoreModules-prefix.pch │ │ │ │ │ ├── React-CoreModules.debug.xcconfig │ │ │ │ │ └── React-CoreModules.release.xcconfig │ │ │ │ ├── React-RCTActionSheet/ │ │ │ │ │ ├── React-RCTActionSheet.debug.xcconfig │ │ │ │ │ └── React-RCTActionSheet.release.xcconfig │ │ │ │ ├── React-RCTAnimation/ │ │ │ │ │ ├── React-RCTAnimation-dummy.m │ │ │ │ │ ├── React-RCTAnimation-prefix.pch │ │ │ │ │ ├── React-RCTAnimation.debug.xcconfig │ │ │ │ │ └── React-RCTAnimation.release.xcconfig │ │ │ │ ├── React-RCTBlob/ │ │ │ │ │ ├── React-RCTBlob-dummy.m │ │ │ │ │ ├── React-RCTBlob-prefix.pch │ │ │ │ │ ├── React-RCTBlob.debug.xcconfig │ │ │ │ │ └── React-RCTBlob.release.xcconfig │ │ │ │ ├── React-RCTImage/ │ │ │ │ │ ├── React-RCTImage-dummy.m │ │ │ │ │ ├── React-RCTImage-prefix.pch │ │ │ │ │ ├── React-RCTImage.debug.xcconfig │ │ │ │ │ └── React-RCTImage.release.xcconfig │ │ │ │ ├── React-RCTLinking/ │ │ │ │ │ ├── React-RCTLinking-dummy.m │ │ │ │ │ ├── React-RCTLinking-prefix.pch │ │ │ │ │ ├── React-RCTLinking.debug.xcconfig │ │ │ │ │ └── React-RCTLinking.release.xcconfig │ │ │ │ ├── React-RCTNetwork/ │ │ │ │ │ ├── React-RCTNetwork-dummy.m │ │ │ │ │ ├── React-RCTNetwork-prefix.pch │ │ │ │ │ ├── React-RCTNetwork.debug.xcconfig │ │ │ │ │ └── React-RCTNetwork.release.xcconfig │ │ │ │ ├── React-RCTSettings/ │ │ │ │ │ ├── React-RCTSettings-dummy.m │ │ │ │ │ ├── React-RCTSettings-prefix.pch │ │ │ │ │ ├── React-RCTSettings.debug.xcconfig │ │ │ │ │ └── React-RCTSettings.release.xcconfig │ │ │ │ ├── React-RCTText/ │ │ │ │ │ ├── React-RCTText-dummy.m │ │ │ │ │ ├── React-RCTText-prefix.pch │ │ │ │ │ ├── React-RCTText.debug.xcconfig │ │ │ │ │ └── React-RCTText.release.xcconfig │ │ │ │ ├── React-RCTVibration/ │ │ │ │ │ ├── React-RCTVibration-dummy.m │ │ │ │ │ ├── React-RCTVibration-prefix.pch │ │ │ │ │ ├── React-RCTVibration.debug.xcconfig │ │ │ │ │ └── React-RCTVibration.release.xcconfig │ │ │ │ ├── React-callinvoker/ │ │ │ │ │ ├── React-callinvoker.debug.xcconfig │ │ │ │ │ └── React-callinvoker.release.xcconfig │ │ │ │ ├── React-cxxreact/ │ │ │ │ │ ├── React-cxxreact-dummy.m │ │ │ │ │ ├── React-cxxreact-prefix.pch │ │ │ │ │ ├── React-cxxreact.debug.xcconfig │ │ │ │ │ └── React-cxxreact.release.xcconfig │ │ │ │ ├── React-jsi/ │ │ │ │ │ ├── React-jsi-dummy.m │ │ │ │ │ ├── React-jsi-prefix.pch │ │ │ │ │ ├── React-jsi.debug.xcconfig │ │ │ │ │ └── React-jsi.release.xcconfig │ │ │ │ ├── React-jsiexecutor/ │ │ │ │ │ ├── React-jsiexecutor-dummy.m │ │ │ │ │ ├── React-jsiexecutor-prefix.pch │ │ │ │ │ ├── React-jsiexecutor.debug.xcconfig │ │ │ │ │ └── React-jsiexecutor.release.xcconfig │ │ │ │ ├── React-jsinspector/ │ │ │ │ │ ├── React-jsinspector-dummy.m │ │ │ │ │ ├── React-jsinspector-prefix.pch │ │ │ │ │ ├── React-jsinspector.debug.xcconfig │ │ │ │ │ └── React-jsinspector.release.xcconfig │ │ │ │ ├── ReactCommon/ │ │ │ │ │ ├── ReactCommon-dummy.m │ │ │ │ │ ├── ReactCommon-prefix.pch │ │ │ │ │ ├── ReactCommon.debug.xcconfig │ │ │ │ │ └── ReactCommon.release.xcconfig │ │ │ │ ├── Yoga/ │ │ │ │ │ ├── Yoga-dummy.m │ │ │ │ │ ├── Yoga-prefix.pch │ │ │ │ │ ├── Yoga-umbrella.h │ │ │ │ │ ├── Yoga.debug.xcconfig │ │ │ │ │ ├── Yoga.modulemap │ │ │ │ │ └── Yoga.release.xcconfig │ │ │ │ ├── boost-for-react-native/ │ │ │ │ │ ├── boost-for-react-native.debug.xcconfig │ │ │ │ │ └── boost-for-react-native.release.xcconfig │ │ │ │ ├── glog/ │ │ │ │ │ ├── glog-dummy.m │ │ │ │ │ ├── glog-prefix.pch │ │ │ │ │ ├── glog.debug.xcconfig │ │ │ │ │ └── glog.release.xcconfig │ │ │ │ └── react-native-receive-sharing-intent/ │ │ │ │ ├── react-native-receive-sharing-intent-dummy.m │ │ │ │ ├── react-native-receive-sharing-intent-prefix.pch │ │ │ │ ├── react-native-receive-sharing-intent-umbrella.h │ │ │ │ ├── react-native-receive-sharing-intent.debug.xcconfig │ │ │ │ ├── react-native-receive-sharing-intent.modulemap │ │ │ │ └── react-native-receive-sharing-intent.release.xcconfig │ │ │ ├── boost-for-react-native/ │ │ │ │ ├── LICENSE_1_0.txt │ │ │ │ ├── README.md │ │ │ │ └── boost/ │ │ │ │ ├── accumulators/ │ │ │ │ │ ├── accumulators.hpp │ │ │ │ │ ├── accumulators_fwd.hpp │ │ │ │ │ ├── framework/ │ │ │ │ │ │ ├── accumulator_base.hpp │ │ │ │ │ │ ├── accumulator_concept.hpp │ │ │ │ │ │ ├── accumulator_set.hpp │ │ │ │ │ │ ├── accumulators/ │ │ │ │ │ │ │ ├── droppable_accumulator.hpp │ │ │ │ │ │ │ ├── external_accumulator.hpp │ │ │ │ │ │ │ ├── reference_accumulator.hpp │ │ │ │ │ │ │ └── value_accumulator.hpp │ │ │ │ │ │ ├── depends_on.hpp │ │ │ │ │ │ ├── external.hpp │ │ │ │ │ │ ├── extractor.hpp │ │ │ │ │ │ ├── features.hpp │ │ │ │ │ │ └── parameters/ │ │ │ │ │ │ ├── accumulator.hpp │ │ │ │ │ │ ├── sample.hpp │ │ │ │ │ │ ├── weight.hpp │ │ │ │ │ │ └── weights.hpp │ │ │ │ │ ├── numeric/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── function1.hpp │ │ │ │ │ │ │ ├── function2.hpp │ │ │ │ │ │ │ ├── function3.hpp │ │ │ │ │ │ │ ├── function4.hpp │ │ │ │ │ │ │ ├── function_n.hpp │ │ │ │ │ │ │ └── pod_singleton.hpp │ │ │ │ │ │ ├── functional/ │ │ │ │ │ │ │ ├── complex.hpp │ │ │ │ │ │ │ ├── valarray.hpp │ │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ │ ├── functional.hpp │ │ │ │ │ │ └── functional_fwd.hpp │ │ │ │ │ ├── statistics/ │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ ├── covariance.hpp │ │ │ │ │ │ ├── density.hpp │ │ │ │ │ │ ├── error_of.hpp │ │ │ │ │ │ ├── error_of_mean.hpp │ │ │ │ │ │ ├── extended_p_square.hpp │ │ │ │ │ │ ├── extended_p_square_quantile.hpp │ │ │ │ │ │ ├── kurtosis.hpp │ │ │ │ │ │ ├── max.hpp │ │ │ │ │ │ ├── mean.hpp │ │ │ │ │ │ ├── median.hpp │ │ │ │ │ │ ├── min.hpp │ │ │ │ │ │ ├── moment.hpp │ │ │ │ │ │ ├── p_square_cumul_dist.hpp │ │ │ │ │ │ ├── p_square_cumulative_distribution.hpp │ │ │ │ │ │ ├── p_square_quantile.hpp │ │ │ │ │ │ ├── parameters/ │ │ │ │ │ │ │ └── quantile_probability.hpp │ │ │ │ │ │ ├── peaks_over_threshold.hpp │ │ │ │ │ │ ├── pot_quantile.hpp │ │ │ │ │ │ ├── pot_tail_mean.hpp │ │ │ │ │ │ ├── rolling_count.hpp │ │ │ │ │ │ ├── rolling_mean.hpp │ │ │ │ │ │ ├── rolling_moment.hpp │ │ │ │ │ │ ├── rolling_sum.hpp │ │ │ │ │ │ ├── rolling_variance.hpp │ │ │ │ │ │ ├── rolling_window.hpp │ │ │ │ │ │ ├── skewness.hpp │ │ │ │ │ │ ├── stats.hpp │ │ │ │ │ │ ├── sum.hpp │ │ │ │ │ │ ├── sum_kahan.hpp │ │ │ │ │ │ ├── tail.hpp │ │ │ │ │ │ ├── tail_mean.hpp │ │ │ │ │ │ ├── tail_quantile.hpp │ │ │ │ │ │ ├── tail_variate.hpp │ │ │ │ │ │ ├── tail_variate_means.hpp │ │ │ │ │ │ ├── times2_iterator.hpp │ │ │ │ │ │ ├── variance.hpp │ │ │ │ │ │ ├── variates/ │ │ │ │ │ │ │ └── covariate.hpp │ │ │ │ │ │ ├── weighted_covariance.hpp │ │ │ │ │ │ ├── weighted_density.hpp │ │ │ │ │ │ ├── weighted_extended_p_square.hpp │ │ │ │ │ │ ├── weighted_kurtosis.hpp │ │ │ │ │ │ ├── weighted_mean.hpp │ │ │ │ │ │ ├── weighted_median.hpp │ │ │ │ │ │ ├── weighted_moment.hpp │ │ │ │ │ │ ├── weighted_p_square_cumul_dist.hpp │ │ │ │ │ │ ├── weighted_p_square_cumulative_distribution.hpp │ │ │ │ │ │ ├── weighted_p_square_quantile.hpp │ │ │ │ │ │ ├── weighted_peaks_over_threshold.hpp │ │ │ │ │ │ ├── weighted_skewness.hpp │ │ │ │ │ │ ├── weighted_sum.hpp │ │ │ │ │ │ ├── weighted_sum_kahan.hpp │ │ │ │ │ │ ├── weighted_tail_mean.hpp │ │ │ │ │ │ ├── weighted_tail_quantile.hpp │ │ │ │ │ │ ├── weighted_tail_variate_means.hpp │ │ │ │ │ │ ├── weighted_variance.hpp │ │ │ │ │ │ └── with_error.hpp │ │ │ │ │ ├── statistics.hpp │ │ │ │ │ └── statistics_fwd.hpp │ │ │ │ ├── algorithm/ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── clamp.hpp │ │ │ │ │ ├── cxx11/ │ │ │ │ │ │ ├── all_of.hpp │ │ │ │ │ │ ├── any_of.hpp │ │ │ │ │ │ ├── copy_if.hpp │ │ │ │ │ │ ├── copy_n.hpp │ │ │ │ │ │ ├── find_if_not.hpp │ │ │ │ │ │ ├── iota.hpp │ │ │ │ │ │ ├── is_partitioned.hpp │ │ │ │ │ │ ├── is_permutation.hpp │ │ │ │ │ │ ├── is_sorted.hpp │ │ │ │ │ │ ├── none_of.hpp │ │ │ │ │ │ ├── one_of.hpp │ │ │ │ │ │ ├── partition_copy.hpp │ │ │ │ │ │ └── partition_point.hpp │ │ │ │ │ ├── cxx14/ │ │ │ │ │ │ ├── equal.hpp │ │ │ │ │ │ ├── is_permutation.hpp │ │ │ │ │ │ └── mismatch.hpp │ │ │ │ │ ├── gather.hpp │ │ │ │ │ ├── hex.hpp │ │ │ │ │ ├── is_palindrome.hpp │ │ │ │ │ ├── minmax.hpp │ │ │ │ │ ├── minmax_element.hpp │ │ │ │ │ ├── searching/ │ │ │ │ │ │ ├── boyer_moore.hpp │ │ │ │ │ │ ├── boyer_moore_horspool.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── bm_traits.hpp │ │ │ │ │ │ │ └── debugging.hpp │ │ │ │ │ │ └── knuth_morris_pratt.hpp │ │ │ │ │ ├── sort_subrange.hpp │ │ │ │ │ ├── string/ │ │ │ │ │ │ ├── case_conv.hpp │ │ │ │ │ │ ├── classification.hpp │ │ │ │ │ │ ├── compare.hpp │ │ │ │ │ │ ├── concept.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── constants.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── case_conv.hpp │ │ │ │ │ │ │ ├── classification.hpp │ │ │ │ │ │ │ ├── find_format.hpp │ │ │ │ │ │ │ ├── find_format_all.hpp │ │ │ │ │ │ │ ├── find_format_store.hpp │ │ │ │ │ │ │ ├── find_iterator.hpp │ │ │ │ │ │ │ ├── finder.hpp │ │ │ │ │ │ │ ├── finder_regex.hpp │ │ │ │ │ │ │ ├── formatter.hpp │ │ │ │ │ │ │ ├── formatter_regex.hpp │ │ │ │ │ │ │ ├── predicate.hpp │ │ │ │ │ │ │ ├── replace_storage.hpp │ │ │ │ │ │ │ ├── sequence.hpp │ │ │ │ │ │ │ ├── trim.hpp │ │ │ │ │ │ │ └── util.hpp │ │ │ │ │ │ ├── erase.hpp │ │ │ │ │ │ ├── find.hpp │ │ │ │ │ │ ├── find_format.hpp │ │ │ │ │ │ ├── find_iterator.hpp │ │ │ │ │ │ ├── finder.hpp │ │ │ │ │ │ ├── formatter.hpp │ │ │ │ │ │ ├── iter_find.hpp │ │ │ │ │ │ ├── join.hpp │ │ │ │ │ │ ├── predicate.hpp │ │ │ │ │ │ ├── predicate_facade.hpp │ │ │ │ │ │ ├── regex.hpp │ │ │ │ │ │ ├── regex_find_format.hpp │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ ├── sequence_traits.hpp │ │ │ │ │ │ ├── split.hpp │ │ │ │ │ │ ├── std/ │ │ │ │ │ │ │ ├── list_traits.hpp │ │ │ │ │ │ │ ├── rope_traits.hpp │ │ │ │ │ │ │ ├── slist_traits.hpp │ │ │ │ │ │ │ └── string_traits.hpp │ │ │ │ │ │ ├── std_containers_traits.hpp │ │ │ │ │ │ ├── trim.hpp │ │ │ │ │ │ ├── trim_all.hpp │ │ │ │ │ │ └── yes_no_type.hpp │ │ │ │ │ ├── string.hpp │ │ │ │ │ └── string_regex.hpp │ │ │ │ ├── align/ │ │ │ │ │ ├── align.hpp │ │ │ │ │ ├── align_down.hpp │ │ │ │ │ ├── align_down_forward.hpp │ │ │ │ │ ├── align_up.hpp │ │ │ │ │ ├── align_up_forward.hpp │ │ │ │ │ ├── aligned_alloc.hpp │ │ │ │ │ ├── aligned_allocator.hpp │ │ │ │ │ ├── aligned_allocator_adaptor.hpp │ │ │ │ │ ├── aligned_allocator_adaptor_forward.hpp │ │ │ │ │ ├── aligned_allocator_forward.hpp │ │ │ │ │ ├── aligned_delete.hpp │ │ │ │ │ ├── aligned_delete_forward.hpp │ │ │ │ │ ├── alignment_of.hpp │ │ │ │ │ ├── alignment_of_forward.hpp │ │ │ │ │ ├── assume_aligned.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── address.hpp │ │ │ │ │ │ ├── addressof.hpp │ │ │ │ │ │ ├── align.hpp │ │ │ │ │ │ ├── align_cxx11.hpp │ │ │ │ │ │ ├── align_down.hpp │ │ │ │ │ │ ├── align_up.hpp │ │ │ │ │ │ ├── aligned_alloc.hpp │ │ │ │ │ │ ├── aligned_alloc_android.hpp │ │ │ │ │ │ ├── aligned_alloc_macos.hpp │ │ │ │ │ │ ├── aligned_alloc_msvc.hpp │ │ │ │ │ │ ├── aligned_alloc_posix.hpp │ │ │ │ │ │ ├── aligned_alloc_sunos.hpp │ │ │ │ │ │ ├── alignment_of.hpp │ │ │ │ │ │ ├── alignment_of_clang.hpp │ │ │ │ │ │ ├── alignment_of_codegear.hpp │ │ │ │ │ │ ├── alignment_of_cxx11.hpp │ │ │ │ │ │ ├── alignment_of_gcc.hpp │ │ │ │ │ │ ├── alignment_of_msvc.hpp │ │ │ │ │ │ ├── assume_aligned.hpp │ │ │ │ │ │ ├── assume_aligned_clang.hpp │ │ │ │ │ │ ├── assume_aligned_gcc.hpp │ │ │ │ │ │ ├── assume_aligned_intel.hpp │ │ │ │ │ │ ├── assume_aligned_msvc.hpp │ │ │ │ │ │ ├── element_type.hpp │ │ │ │ │ │ ├── integral_constant.hpp │ │ │ │ │ │ ├── is_aligned.hpp │ │ │ │ │ │ ├── is_alignment.hpp │ │ │ │ │ │ ├── is_alignment_constant.hpp │ │ │ │ │ │ ├── max_align.hpp │ │ │ │ │ │ ├── max_count_of.hpp │ │ │ │ │ │ ├── max_objects.hpp │ │ │ │ │ │ ├── max_size.hpp │ │ │ │ │ │ ├── min_size.hpp │ │ │ │ │ │ ├── offset_object.hpp │ │ │ │ │ │ └── remove_traits.hpp │ │ │ │ │ ├── is_aligned.hpp │ │ │ │ │ └── is_aligned_forward.hpp │ │ │ │ ├── align.hpp │ │ │ │ ├── aligned_storage.hpp │ │ │ │ ├── any.hpp │ │ │ │ ├── archive/ │ │ │ │ │ ├── add_facet.hpp │ │ │ │ │ ├── archive_exception.hpp │ │ │ │ │ ├── basic_archive.hpp │ │ │ │ │ ├── basic_binary_iarchive.hpp │ │ │ │ │ ├── basic_binary_iprimitive.hpp │ │ │ │ │ ├── basic_binary_oarchive.hpp │ │ │ │ │ ├── basic_binary_oprimitive.hpp │ │ │ │ │ ├── basic_streambuf_locale_saver.hpp │ │ │ │ │ ├── basic_text_iarchive.hpp │ │ │ │ │ ├── basic_text_iprimitive.hpp │ │ │ │ │ ├── basic_text_oarchive.hpp │ │ │ │ │ ├── basic_text_oprimitive.hpp │ │ │ │ │ ├── basic_xml_archive.hpp │ │ │ │ │ ├── basic_xml_iarchive.hpp │ │ │ │ │ ├── basic_xml_oarchive.hpp │ │ │ │ │ ├── binary_iarchive.hpp │ │ │ │ │ ├── binary_iarchive_impl.hpp │ │ │ │ │ ├── binary_oarchive.hpp │ │ │ │ │ ├── binary_oarchive_impl.hpp │ │ │ │ │ ├── binary_wiarchive.hpp │ │ │ │ │ ├── binary_woarchive.hpp │ │ │ │ │ ├── codecvt_null.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── abi_prefix.hpp │ │ │ │ │ │ ├── abi_suffix.hpp │ │ │ │ │ │ ├── archive_serializer_map.hpp │ │ │ │ │ │ ├── auto_link_archive.hpp │ │ │ │ │ │ ├── auto_link_warchive.hpp │ │ │ │ │ │ ├── basic_archive_impl.hpp │ │ │ │ │ │ ├── basic_config.hpp │ │ │ │ │ │ ├── basic_iarchive.hpp │ │ │ │ │ │ ├── basic_iserializer.hpp │ │ │ │ │ │ ├── basic_oarchive.hpp │ │ │ │ │ │ ├── basic_oserializer.hpp │ │ │ │ │ │ ├── basic_pointer_iserializer.hpp │ │ │ │ │ │ ├── basic_pointer_oserializer.hpp │ │ │ │ │ │ ├── basic_serializer.hpp │ │ │ │ │ │ ├── basic_serializer_map.hpp │ │ │ │ │ │ ├── check.hpp │ │ │ │ │ │ ├── common_iarchive.hpp │ │ │ │ │ │ ├── common_oarchive.hpp │ │ │ │ │ │ ├── decl.hpp │ │ │ │ │ │ ├── helper_collection.hpp │ │ │ │ │ │ ├── interface_iarchive.hpp │ │ │ │ │ │ ├── interface_oarchive.hpp │ │ │ │ │ │ ├── iserializer.hpp │ │ │ │ │ │ ├── oserializer.hpp │ │ │ │ │ │ ├── polymorphic_iarchive_route.hpp │ │ │ │ │ │ ├── polymorphic_oarchive_route.hpp │ │ │ │ │ │ ├── register_archive.hpp │ │ │ │ │ │ └── utf8_codecvt_facet.hpp │ │ │ │ │ ├── dinkumware.hpp │ │ │ │ │ ├── impl/ │ │ │ │ │ │ ├── archive_serializer_map.ipp │ │ │ │ │ │ ├── basic_binary_iarchive.ipp │ │ │ │ │ │ ├── basic_binary_iprimitive.ipp │ │ │ │ │ │ ├── basic_binary_oarchive.ipp │ │ │ │ │ │ ├── basic_binary_oprimitive.ipp │ │ │ │ │ │ ├── basic_text_iarchive.ipp │ │ │ │ │ │ ├── basic_text_iprimitive.ipp │ │ │ │ │ │ ├── basic_text_oarchive.ipp │ │ │ │ │ │ ├── basic_text_oprimitive.ipp │ │ │ │ │ │ ├── basic_xml_grammar.hpp │ │ │ │ │ │ ├── basic_xml_iarchive.ipp │ │ │ │ │ │ ├── basic_xml_oarchive.ipp │ │ │ │ │ │ ├── text_iarchive_impl.ipp │ │ │ │ │ │ ├── text_oarchive_impl.ipp │ │ │ │ │ │ ├── text_wiarchive_impl.ipp │ │ │ │ │ │ ├── text_woarchive_impl.ipp │ │ │ │ │ │ ├── xml_iarchive_impl.ipp │ │ │ │ │ │ ├── xml_oarchive_impl.ipp │ │ │ │ │ │ ├── xml_wiarchive_impl.ipp │ │ │ │ │ │ └── xml_woarchive_impl.ipp │ │ │ │ │ ├── iterators/ │ │ │ │ │ │ ├── base64_exception.hpp │ │ │ │ │ │ ├── base64_from_binary.hpp │ │ │ │ │ │ ├── binary_from_base64.hpp │ │ │ │ │ │ ├── dataflow.hpp │ │ │ │ │ │ ├── dataflow_exception.hpp │ │ │ │ │ │ ├── escape.hpp │ │ │ │ │ │ ├── head_iterator.hpp │ │ │ │ │ │ ├── insert_linebreaks.hpp │ │ │ │ │ │ ├── istream_iterator.hpp │ │ │ │ │ │ ├── mb_from_wchar.hpp │ │ │ │ │ │ ├── ostream_iterator.hpp │ │ │ │ │ │ ├── remove_whitespace.hpp │ │ │ │ │ │ ├── transform_width.hpp │ │ │ │ │ │ ├── unescape.hpp │ │ │ │ │ │ ├── wchar_from_mb.hpp │ │ │ │ │ │ ├── xml_escape.hpp │ │ │ │ │ │ ├── xml_unescape.hpp │ │ │ │ │ │ └── xml_unescape_exception.hpp │ │ │ │ │ ├── polymorphic_binary_iarchive.hpp │ │ │ │ │ ├── polymorphic_binary_oarchive.hpp │ │ │ │ │ ├── polymorphic_iarchive.hpp │ │ │ │ │ ├── polymorphic_oarchive.hpp │ │ │ │ │ ├── polymorphic_text_iarchive.hpp │ │ │ │ │ ├── polymorphic_text_oarchive.hpp │ │ │ │ │ ├── polymorphic_text_wiarchive.hpp │ │ │ │ │ ├── polymorphic_text_woarchive.hpp │ │ │ │ │ ├── polymorphic_xml_iarchive.hpp │ │ │ │ │ ├── polymorphic_xml_oarchive.hpp │ │ │ │ │ ├── polymorphic_xml_wiarchive.hpp │ │ │ │ │ ├── polymorphic_xml_woarchive.hpp │ │ │ │ │ ├── shared_ptr_helper.hpp │ │ │ │ │ ├── text_iarchive.hpp │ │ │ │ │ ├── text_oarchive.hpp │ │ │ │ │ ├── text_wiarchive.hpp │ │ │ │ │ ├── text_woarchive.hpp │ │ │ │ │ ├── tmpdir.hpp │ │ │ │ │ ├── wcslen.hpp │ │ │ │ │ ├── xml_archive_exception.hpp │ │ │ │ │ ├── xml_iarchive.hpp │ │ │ │ │ ├── xml_oarchive.hpp │ │ │ │ │ ├── xml_wiarchive.hpp │ │ │ │ │ └── xml_woarchive.hpp │ │ │ │ ├── array.hpp │ │ │ │ ├── asio/ │ │ │ │ │ ├── async_result.hpp │ │ │ │ │ ├── basic_datagram_socket.hpp │ │ │ │ │ ├── basic_deadline_timer.hpp │ │ │ │ │ ├── basic_io_object.hpp │ │ │ │ │ ├── basic_raw_socket.hpp │ │ │ │ │ ├── basic_seq_packet_socket.hpp │ │ │ │ │ ├── basic_serial_port.hpp │ │ │ │ │ ├── basic_signal_set.hpp │ │ │ │ │ ├── basic_socket.hpp │ │ │ │ │ ├── basic_socket_acceptor.hpp │ │ │ │ │ ├── basic_socket_iostream.hpp │ │ │ │ │ ├── basic_socket_streambuf.hpp │ │ │ │ │ ├── basic_stream_socket.hpp │ │ │ │ │ ├── basic_streambuf.hpp │ │ │ │ │ ├── basic_streambuf_fwd.hpp │ │ │ │ │ ├── basic_waitable_timer.hpp │ │ │ │ │ ├── buffer.hpp │ │ │ │ │ ├── buffered_read_stream.hpp │ │ │ │ │ ├── buffered_read_stream_fwd.hpp │ │ │ │ │ ├── buffered_stream.hpp │ │ │ │ │ ├── buffered_stream_fwd.hpp │ │ │ │ │ ├── buffered_write_stream.hpp │ │ │ │ │ ├── buffered_write_stream_fwd.hpp │ │ │ │ │ ├── buffers_iterator.hpp │ │ │ │ │ ├── completion_condition.hpp │ │ │ │ │ ├── connect.hpp │ │ │ │ │ ├── coroutine.hpp │ │ │ │ │ ├── datagram_socket_service.hpp │ │ │ │ │ ├── deadline_timer.hpp │ │ │ │ │ ├── deadline_timer_service.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── addressof.hpp │ │ │ │ │ │ ├── array.hpp │ │ │ │ │ │ ├── array_fwd.hpp │ │ │ │ │ │ ├── assert.hpp │ │ │ │ │ │ ├── atomic_count.hpp │ │ │ │ │ │ ├── base_from_completion_cond.hpp │ │ │ │ │ │ ├── bind_handler.hpp │ │ │ │ │ │ ├── buffer_resize_guard.hpp │ │ │ │ │ │ ├── buffer_sequence_adapter.hpp │ │ │ │ │ │ ├── buffered_stream_storage.hpp │ │ │ │ │ │ ├── call_stack.hpp │ │ │ │ │ │ ├── chrono_time_traits.hpp │ │ │ │ │ │ ├── completion_handler.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── consuming_buffers.hpp │ │ │ │ │ │ ├── cstdint.hpp │ │ │ │ │ │ ├── date_time_fwd.hpp │ │ │ │ │ │ ├── deadline_timer_service.hpp │ │ │ │ │ │ ├── dependent_type.hpp │ │ │ │ │ │ ├── descriptor_ops.hpp │ │ │ │ │ │ ├── descriptor_read_op.hpp │ │ │ │ │ │ ├── descriptor_write_op.hpp │ │ │ │ │ │ ├── dev_poll_reactor.hpp │ │ │ │ │ │ ├── epoll_reactor.hpp │ │ │ │ │ │ ├── event.hpp │ │ │ │ │ │ ├── eventfd_select_interrupter.hpp │ │ │ │ │ │ ├── fd_set_adapter.hpp │ │ │ │ │ │ ├── fenced_block.hpp │ │ │ │ │ │ ├── function.hpp │ │ │ │ │ │ ├── gcc_arm_fenced_block.hpp │ │ │ │ │ │ ├── gcc_hppa_fenced_block.hpp │ │ │ │ │ │ ├── gcc_sync_fenced_block.hpp │ │ │ │ │ │ ├── gcc_x86_fenced_block.hpp │ │ │ │ │ │ ├── handler_alloc_helpers.hpp │ │ │ │ │ │ ├── handler_cont_helpers.hpp │ │ │ │ │ │ ├── handler_invoke_helpers.hpp │ │ │ │ │ │ ├── handler_tracking.hpp │ │ │ │ │ │ ├── handler_type_requirements.hpp │ │ │ │ │ │ ├── hash_map.hpp │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ ├── buffer_sequence_adapter.ipp │ │ │ │ │ │ │ ├── descriptor_ops.ipp │ │ │ │ │ │ │ ├── dev_poll_reactor.hpp │ │ │ │ │ │ │ ├── dev_poll_reactor.ipp │ │ │ │ │ │ │ ├── epoll_reactor.hpp │ │ │ │ │ │ │ ├── epoll_reactor.ipp │ │ │ │ │ │ │ ├── eventfd_select_interrupter.ipp │ │ │ │ │ │ │ ├── handler_tracking.ipp │ │ │ │ │ │ │ ├── kqueue_reactor.hpp │ │ │ │ │ │ │ ├── kqueue_reactor.ipp │ │ │ │ │ │ │ ├── pipe_select_interrupter.ipp │ │ │ │ │ │ │ ├── posix_event.ipp │ │ │ │ │ │ │ ├── posix_mutex.ipp │ │ │ │ │ │ │ ├── posix_thread.ipp │ │ │ │ │ │ │ ├── posix_tss_ptr.ipp │ │ │ │ │ │ │ ├── reactive_descriptor_service.ipp │ │ │ │ │ │ │ ├── reactive_serial_port_service.ipp │ │ │ │ │ │ │ ├── reactive_socket_service_base.ipp │ │ │ │ │ │ │ ├── resolver_service_base.ipp │ │ │ │ │ │ │ ├── select_reactor.hpp │ │ │ │ │ │ │ ├── select_reactor.ipp │ │ │ │ │ │ │ ├── service_registry.hpp │ │ │ │ │ │ │ ├── service_registry.ipp │ │ │ │ │ │ │ ├── signal_set_service.ipp │ │ │ │ │ │ │ ├── socket_ops.ipp │ │ │ │ │ │ │ ├── socket_select_interrupter.ipp │ │ │ │ │ │ │ ├── strand_service.hpp │ │ │ │ │ │ │ ├── strand_service.ipp │ │ │ │ │ │ │ ├── task_io_service.hpp │ │ │ │ │ │ │ ├── task_io_service.ipp │ │ │ │ │ │ │ ├── throw_error.ipp │ │ │ │ │ │ │ ├── timer_queue_ptime.ipp │ │ │ │ │ │ │ ├── timer_queue_set.ipp │ │ │ │ │ │ │ ├── win_event.ipp │ │ │ │ │ │ │ ├── win_iocp_handle_service.ipp │ │ │ │ │ │ │ ├── win_iocp_io_service.hpp │ │ │ │ │ │ │ ├── win_iocp_io_service.ipp │ │ │ │ │ │ │ ├── win_iocp_serial_port_service.ipp │ │ │ │ │ │ │ ├── win_iocp_socket_service_base.ipp │ │ │ │ │ │ │ ├── win_mutex.ipp │ │ │ │ │ │ │ ├── win_object_handle_service.ipp │ │ │ │ │ │ │ ├── win_static_mutex.ipp │ │ │ │ │ │ │ ├── win_thread.ipp │ │ │ │ │ │ │ ├── win_tss_ptr.ipp │ │ │ │ │ │ │ ├── winrt_ssocket_service_base.ipp │ │ │ │ │ │ │ ├── winrt_timer_scheduler.hpp │ │ │ │ │ │ │ ├── winrt_timer_scheduler.ipp │ │ │ │ │ │ │ └── winsock_init.ipp │ │ │ │ │ │ ├── io_control.hpp │ │ │ │ │ │ ├── keyword_tss_ptr.hpp │ │ │ │ │ │ ├── kqueue_reactor.hpp │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ ├── local_free_on_block_exit.hpp │ │ │ │ │ │ ├── macos_fenced_block.hpp │ │ │ │ │ │ ├── mutex.hpp │ │ │ │ │ │ ├── noncopyable.hpp │ │ │ │ │ │ ├── null_event.hpp │ │ │ │ │ │ ├── null_fenced_block.hpp │ │ │ │ │ │ ├── null_mutex.hpp │ │ │ │ │ │ ├── null_reactor.hpp │ │ │ │ │ │ ├── null_signal_blocker.hpp │ │ │ │ │ │ ├── null_socket_service.hpp │ │ │ │ │ │ ├── null_static_mutex.hpp │ │ │ │ │ │ ├── null_thread.hpp │ │ │ │ │ │ ├── null_tss_ptr.hpp │ │ │ │ │ │ ├── object_pool.hpp │ │ │ │ │ │ ├── old_win_sdk_compat.hpp │ │ │ │ │ │ ├── op_queue.hpp │ │ │ │ │ │ ├── operation.hpp │ │ │ │ │ │ ├── pipe_select_interrupter.hpp │ │ │ │ │ │ ├── pop_options.hpp │ │ │ │ │ │ ├── posix_event.hpp │ │ │ │ │ │ ├── posix_fd_set_adapter.hpp │ │ │ │ │ │ ├── posix_mutex.hpp │ │ │ │ │ │ ├── posix_signal_blocker.hpp │ │ │ │ │ │ ├── posix_static_mutex.hpp │ │ │ │ │ │ ├── posix_thread.hpp │ │ │ │ │ │ ├── posix_tss_ptr.hpp │ │ │ │ │ │ ├── push_options.hpp │ │ │ │ │ │ ├── reactive_descriptor_service.hpp │ │ │ │ │ │ ├── reactive_null_buffers_op.hpp │ │ │ │ │ │ ├── reactive_serial_port_service.hpp │ │ │ │ │ │ ├── reactive_socket_accept_op.hpp │ │ │ │ │ │ ├── reactive_socket_connect_op.hpp │ │ │ │ │ │ ├── reactive_socket_recv_op.hpp │ │ │ │ │ │ ├── reactive_socket_recvfrom_op.hpp │ │ │ │ │ │ ├── reactive_socket_recvmsg_op.hpp │ │ │ │ │ │ ├── reactive_socket_send_op.hpp │ │ │ │ │ │ ├── reactive_socket_sendto_op.hpp │ │ │ │ │ │ ├── reactive_socket_service.hpp │ │ │ │ │ │ ├── reactive_socket_service_base.hpp │ │ │ │ │ │ ├── reactor.hpp │ │ │ │ │ │ ├── reactor_fwd.hpp │ │ │ │ │ │ ├── reactor_op.hpp │ │ │ │ │ │ ├── reactor_op_queue.hpp │ │ │ │ │ │ ├── regex_fwd.hpp │ │ │ │ │ │ ├── resolve_endpoint_op.hpp │ │ │ │ │ │ ├── resolve_op.hpp │ │ │ │ │ │ ├── resolver_service.hpp │ │ │ │ │ │ ├── resolver_service_base.hpp │ │ │ │ │ │ ├── scoped_lock.hpp │ │ │ │ │ │ ├── scoped_ptr.hpp │ │ │ │ │ │ ├── select_interrupter.hpp │ │ │ │ │ │ ├── select_reactor.hpp │ │ │ │ │ │ ├── service_registry.hpp │ │ │ │ │ │ ├── shared_ptr.hpp │ │ │ │ │ │ ├── signal_blocker.hpp │ │ │ │ │ │ ├── signal_handler.hpp │ │ │ │ │ │ ├── signal_init.hpp │ │ │ │ │ │ ├── signal_op.hpp │ │ │ │ │ │ ├── signal_set_service.hpp │ │ │ │ │ │ ├── socket_holder.hpp │ │ │ │ │ │ ├── socket_ops.hpp │ │ │ │ │ │ ├── socket_option.hpp │ │ │ │ │ │ ├── socket_select_interrupter.hpp │ │ │ │ │ │ ├── socket_types.hpp │ │ │ │ │ │ ├── solaris_fenced_block.hpp │ │ │ │ │ │ ├── static_mutex.hpp │ │ │ │ │ │ ├── std_event.hpp │ │ │ │ │ │ ├── std_mutex.hpp │ │ │ │ │ │ ├── std_static_mutex.hpp │ │ │ │ │ │ ├── std_thread.hpp │ │ │ │ │ │ ├── strand_service.hpp │ │ │ │ │ │ ├── task_io_service.hpp │ │ │ │ │ │ ├── task_io_service_operation.hpp │ │ │ │ │ │ ├── task_io_service_thread_info.hpp │ │ │ │ │ │ ├── thread.hpp │ │ │ │ │ │ ├── thread_info_base.hpp │ │ │ │ │ │ ├── throw_error.hpp │ │ │ │ │ │ ├── throw_exception.hpp │ │ │ │ │ │ ├── timer_queue.hpp │ │ │ │ │ │ ├── timer_queue_base.hpp │ │ │ │ │ │ ├── timer_queue_ptime.hpp │ │ │ │ │ │ ├── timer_queue_set.hpp │ │ │ │ │ │ ├── timer_scheduler.hpp │ │ │ │ │ │ ├── timer_scheduler_fwd.hpp │ │ │ │ │ │ ├── tss_ptr.hpp │ │ │ │ │ │ ├── type_traits.hpp │ │ │ │ │ │ ├── variadic_templates.hpp │ │ │ │ │ │ ├── wait_handler.hpp │ │ │ │ │ │ ├── wait_op.hpp │ │ │ │ │ │ ├── weak_ptr.hpp │ │ │ │ │ │ ├── win_event.hpp │ │ │ │ │ │ ├── win_fd_set_adapter.hpp │ │ │ │ │ │ ├── win_fenced_block.hpp │ │ │ │ │ │ ├── win_iocp_handle_read_op.hpp │ │ │ │ │ │ ├── win_iocp_handle_service.hpp │ │ │ │ │ │ ├── win_iocp_handle_write_op.hpp │ │ │ │ │ │ ├── win_iocp_io_service.hpp │ │ │ │ │ │ ├── win_iocp_null_buffers_op.hpp │ │ │ │ │ │ ├── win_iocp_operation.hpp │ │ │ │ │ │ ├── win_iocp_overlapped_op.hpp │ │ │ │ │ │ ├── win_iocp_overlapped_ptr.hpp │ │ │ │ │ │ ├── win_iocp_serial_port_service.hpp │ │ │ │ │ │ ├── win_iocp_socket_accept_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_connect_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_recv_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_recvfrom_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_recvmsg_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_send_op.hpp │ │ │ │ │ │ ├── win_iocp_socket_service.hpp │ │ │ │ │ │ ├── win_iocp_socket_service_base.hpp │ │ │ │ │ │ ├── win_iocp_thread_info.hpp │ │ │ │ │ │ ├── win_mutex.hpp │ │ │ │ │ │ ├── win_object_handle_service.hpp │ │ │ │ │ │ ├── win_static_mutex.hpp │ │ │ │ │ │ ├── win_thread.hpp │ │ │ │ │ │ ├── win_tss_ptr.hpp │ │ │ │ │ │ ├── winapi_thread.hpp │ │ │ │ │ │ ├── wince_thread.hpp │ │ │ │ │ │ ├── winrt_async_manager.hpp │ │ │ │ │ │ ├── winrt_async_op.hpp │ │ │ │ │ │ ├── winrt_resolve_op.hpp │ │ │ │ │ │ ├── winrt_resolver_service.hpp │ │ │ │ │ │ ├── winrt_socket_connect_op.hpp │ │ │ │ │ │ ├── winrt_socket_recv_op.hpp │ │ │ │ │ │ ├── winrt_socket_send_op.hpp │ │ │ │ │ │ ├── winrt_ssocket_service.hpp │ │ │ │ │ │ ├── winrt_ssocket_service_base.hpp │ │ │ │ │ │ ├── winrt_timer_scheduler.hpp │ │ │ │ │ │ ├── winrt_utils.hpp │ │ │ │ │ │ ├── winsock_init.hpp │ │ │ │ │ │ └── wrapped_handler.hpp │ │ │ │ │ ├── error.hpp │ │ │ │ │ ├── generic/ │ │ │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ │ │ ├── datagram_protocol.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── endpoint.hpp │ │ │ │ │ │ │ └── impl/ │ │ │ │ │ │ │ └── endpoint.ipp │ │ │ │ │ │ ├── raw_protocol.hpp │ │ │ │ │ │ ├── seq_packet_protocol.hpp │ │ │ │ │ │ └── stream_protocol.hpp │ │ │ │ │ ├── handler_alloc_hook.hpp │ │ │ │ │ ├── handler_continuation_hook.hpp │ │ │ │ │ ├── handler_invoke_hook.hpp │ │ │ │ │ ├── handler_type.hpp │ │ │ │ │ ├── high_resolution_timer.hpp │ │ │ │ │ ├── impl/ │ │ │ │ │ │ ├── buffered_read_stream.hpp │ │ │ │ │ │ ├── buffered_write_stream.hpp │ │ │ │ │ │ ├── connect.hpp │ │ │ │ │ │ ├── error.ipp │ │ │ │ │ │ ├── handler_alloc_hook.ipp │ │ │ │ │ │ ├── io_service.hpp │ │ │ │ │ │ ├── io_service.ipp │ │ │ │ │ │ ├── read.hpp │ │ │ │ │ │ ├── read_at.hpp │ │ │ │ │ │ ├── read_until.hpp │ │ │ │ │ │ ├── serial_port_base.hpp │ │ │ │ │ │ ├── serial_port_base.ipp │ │ │ │ │ │ ├── spawn.hpp │ │ │ │ │ │ ├── src.cpp │ │ │ │ │ │ ├── src.hpp │ │ │ │ │ │ ├── use_future.hpp │ │ │ │ │ │ ├── write.hpp │ │ │ │ │ │ └── write_at.hpp │ │ │ │ │ ├── io_service.hpp │ │ │ │ │ ├── ip/ │ │ │ │ │ │ ├── address.hpp │ │ │ │ │ │ ├── address_v4.hpp │ │ │ │ │ │ ├── address_v6.hpp │ │ │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ │ │ ├── basic_resolver.hpp │ │ │ │ │ │ ├── basic_resolver_entry.hpp │ │ │ │ │ │ ├── basic_resolver_iterator.hpp │ │ │ │ │ │ ├── basic_resolver_query.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── endpoint.hpp │ │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ │ └── endpoint.ipp │ │ │ │ │ │ │ └── socket_option.hpp │ │ │ │ │ │ ├── host_name.hpp │ │ │ │ │ │ ├── icmp.hpp │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ ├── address.hpp │ │ │ │ │ │ │ ├── address.ipp │ │ │ │ │ │ │ ├── address_v4.hpp │ │ │ │ │ │ │ ├── address_v4.ipp │ │ │ │ │ │ │ ├── address_v6.hpp │ │ │ │ │ │ │ ├── address_v6.ipp │ │ │ │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ │ │ │ └── host_name.ipp │ │ │ │ │ │ ├── multicast.hpp │ │ │ │ │ │ ├── resolver_query_base.hpp │ │ │ │ │ │ ├── resolver_service.hpp │ │ │ │ │ │ ├── tcp.hpp │ │ │ │ │ │ ├── udp.hpp │ │ │ │ │ │ ├── unicast.hpp │ │ │ │ │ │ └── v6_only.hpp │ │ │ │ │ ├── is_read_buffered.hpp │ │ │ │ │ ├── is_write_buffered.hpp │ │ │ │ │ ├── local/ │ │ │ │ │ │ ├── basic_endpoint.hpp │ │ │ │ │ │ ├── connect_pair.hpp │ │ │ │ │ │ ├── datagram_protocol.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── endpoint.hpp │ │ │ │ │ │ │ └── impl/ │ │ │ │ │ │ │ └── endpoint.ipp │ │ │ │ │ │ └── stream_protocol.hpp │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ ├── posix/ │ │ │ │ │ │ ├── basic_descriptor.hpp │ │ │ │ │ │ ├── basic_stream_descriptor.hpp │ │ │ │ │ │ ├── descriptor_base.hpp │ │ │ │ │ │ ├── stream_descriptor.hpp │ │ │ │ │ │ └── stream_descriptor_service.hpp │ │ │ │ │ ├── raw_socket_service.hpp │ │ │ │ │ ├── read.hpp │ │ │ │ │ ├── read_at.hpp │ │ │ │ │ ├── read_until.hpp │ │ │ │ │ ├── seq_packet_socket_service.hpp │ │ │ │ │ ├── serial_port.hpp │ │ │ │ │ ├── serial_port_base.hpp │ │ │ │ │ ├── serial_port_service.hpp │ │ │ │ │ ├── signal_set.hpp │ │ │ │ │ ├── signal_set_service.hpp │ │ │ │ │ ├── socket_acceptor_service.hpp │ │ │ │ │ ├── socket_base.hpp │ │ │ │ │ ├── spawn.hpp │ │ │ │ │ ├── ssl/ │ │ │ │ │ │ ├── basic_context.hpp │ │ │ │ │ │ ├── context.hpp │ │ │ │ │ │ ├── context_base.hpp │ │ │ │ │ │ ├── context_service.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── buffered_handshake_op.hpp │ │ │ │ │ │ │ ├── engine.hpp │ │ │ │ │ │ │ ├── handshake_op.hpp │ │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ │ ├── engine.ipp │ │ │ │ │ │ │ │ └── openssl_init.ipp │ │ │ │ │ │ │ ├── io.hpp │ │ │ │ │ │ │ ├── openssl_init.hpp │ │ │ │ │ │ │ ├── openssl_types.hpp │ │ │ │ │ │ │ ├── password_callback.hpp │ │ │ │ │ │ │ ├── read_op.hpp │ │ │ │ │ │ │ ├── shutdown_op.hpp │ │ │ │ │ │ │ ├── stream_core.hpp │ │ │ │ │ │ │ ├── verify_callback.hpp │ │ │ │ │ │ │ └── write_op.hpp │ │ │ │ │ │ ├── error.hpp │ │ │ │ │ │ ├── impl/ │ │ │ │ │ │ │ ├── context.hpp │ │ │ │ │ │ │ ├── context.ipp │ │ │ │ │ │ │ ├── error.ipp │ │ │ │ │ │ │ ├── rfc2818_verification.ipp │ │ │ │ │ │ │ └── src.hpp │ │ │ │ │ │ ├── old/ │ │ │ │ │ │ │ ├── basic_context.hpp │ │ │ │ │ │ │ ├── context_service.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── openssl_context_service.hpp │ │ │ │ │ │ │ │ ├── openssl_operation.hpp │ │ │ │ │ │ │ │ └── openssl_stream_service.hpp │ │ │ │ │ │ │ ├── stream.hpp │ │ │ │ │ │ │ └── stream_service.hpp │ │ │ │ │ │ ├── rfc2818_verification.hpp │ │ │ │ │ │ ├── stream.hpp │ │ │ │ │ │ ├── stream_base.hpp │ │ │ │ │ │ ├── stream_service.hpp │ │ │ │ │ │ ├── verify_context.hpp │ │ │ │ │ │ └── verify_mode.hpp │ │ │ │ │ ├── ssl.hpp │ │ │ │ │ ├── steady_timer.hpp │ │ │ │ │ ├── strand.hpp │ │ │ │ │ ├── stream_socket_service.hpp │ │ │ │ │ ├── streambuf.hpp │ │ │ │ │ ├── system_timer.hpp │ │ │ │ │ ├── time_traits.hpp │ │ │ │ │ ├── unyield.hpp │ │ │ │ │ ├── use_future.hpp │ │ │ │ │ ├── version.hpp │ │ │ │ │ ├── wait_traits.hpp │ │ │ │ │ ├── waitable_timer_service.hpp │ │ │ │ │ ├── windows/ │ │ │ │ │ │ ├── basic_handle.hpp │ │ │ │ │ │ ├── basic_object_handle.hpp │ │ │ │ │ │ ├── basic_random_access_handle.hpp │ │ │ │ │ │ ├── basic_stream_handle.hpp │ │ │ │ │ │ ├── object_handle.hpp │ │ │ │ │ │ ├── object_handle_service.hpp │ │ │ │ │ │ ├── overlapped_ptr.hpp │ │ │ │ │ │ ├── random_access_handle.hpp │ │ │ │ │ │ ├── random_access_handle_service.hpp │ │ │ │ │ │ ├── stream_handle.hpp │ │ │ │ │ │ └── stream_handle_service.hpp │ │ │ │ │ ├── write.hpp │ │ │ │ │ ├── write_at.hpp │ │ │ │ │ └── yield.hpp │ │ │ │ ├── asio.hpp │ │ │ │ ├── assert.hpp │ │ │ │ ├── assign/ │ │ │ │ │ ├── assignment_exception.hpp │ │ │ │ │ ├── list_inserter.hpp │ │ │ │ │ ├── list_of.hpp │ │ │ │ │ ├── ptr_list_inserter.hpp │ │ │ │ │ ├── ptr_list_of.hpp │ │ │ │ │ ├── ptr_map_inserter.hpp │ │ │ │ │ ├── std/ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── queue.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── slist.hpp │ │ │ │ │ │ ├── stack.hpp │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ └── std.hpp │ │ │ │ ├── assign.hpp │ │ │ │ ├── atomic/ │ │ │ │ │ ├── atomic.hpp │ │ │ │ │ ├── atomic_flag.hpp │ │ │ │ │ ├── capabilities.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── atomic_flag.hpp │ │ │ │ │ │ ├── atomic_template.hpp │ │ │ │ │ │ ├── bitwise_cast.hpp │ │ │ │ │ │ ├── caps_gcc_alpha.hpp │ │ │ │ │ │ ├── caps_gcc_arm.hpp │ │ │ │ │ │ ├── caps_gcc_atomic.hpp │ │ │ │ │ │ ├── caps_gcc_ppc.hpp │ │ │ │ │ │ ├── caps_gcc_sparc.hpp │ │ │ │ │ │ ├── caps_gcc_sync.hpp │ │ │ │ │ │ ├── caps_gcc_x86.hpp │ │ │ │ │ │ ├── caps_linux_arm.hpp │ │ │ │ │ │ ├── caps_msvc_arm.hpp │ │ │ │ │ │ ├── caps_msvc_x86.hpp │ │ │ │ │ │ ├── caps_windows.hpp │ │ │ │ │ │ ├── casts.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── int_sizes.hpp │ │ │ │ │ │ ├── interlocked.hpp │ │ │ │ │ │ ├── link.hpp │ │ │ │ │ │ ├── lockpool.hpp │ │ │ │ │ │ ├── operations.hpp │ │ │ │ │ │ ├── operations_fwd.hpp │ │ │ │ │ │ ├── operations_lockfree.hpp │ │ │ │ │ │ ├── ops_cas_based.hpp │ │ │ │ │ │ ├── ops_emulated.hpp │ │ │ │ │ │ ├── ops_extending_cas_based.hpp │ │ │ │ │ │ ├── ops_gcc_alpha.hpp │ │ │ │ │ │ ├── ops_gcc_arm.hpp │ │ │ │ │ │ ├── ops_gcc_atomic.hpp │ │ │ │ │ │ ├── ops_gcc_ppc.hpp │ │ │ │ │ │ ├── ops_gcc_sparc.hpp │ │ │ │ │ │ ├── ops_gcc_sync.hpp │ │ │ │ │ │ ├── ops_gcc_x86.hpp │ │ │ │ │ │ ├── ops_gcc_x86_dcas.hpp │ │ │ │ │ │ ├── ops_linux_arm.hpp │ │ │ │ │ │ ├── ops_msvc_arm.hpp │ │ │ │ │ │ ├── ops_msvc_common.hpp │ │ │ │ │ │ ├── ops_msvc_x86.hpp │ │ │ │ │ │ ├── ops_windows.hpp │ │ │ │ │ │ ├── pause.hpp │ │ │ │ │ │ ├── platform.hpp │ │ │ │ │ │ └── storage_type.hpp │ │ │ │ │ └── fences.hpp │ │ │ │ ├── atomic.hpp │ │ │ │ ├── bimap/ │ │ │ │ │ ├── bimap.hpp │ │ │ │ │ ├── container_adaptor/ │ │ │ │ │ │ ├── associative_container_adaptor.hpp │ │ │ │ │ │ ├── container_adaptor.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── comparison_adaptor.hpp │ │ │ │ │ │ │ ├── functor_bag.hpp │ │ │ │ │ │ │ ├── identity_converters.hpp │ │ │ │ │ │ │ ├── key_extractor.hpp │ │ │ │ │ │ │ └── non_unique_container_helper.hpp │ │ │ │ │ │ ├── list_adaptor.hpp │ │ │ │ │ │ ├── list_map_adaptor.hpp │ │ │ │ │ │ ├── map_adaptor.hpp │ │ │ │ │ │ ├── multimap_adaptor.hpp │ │ │ │ │ │ ├── multiset_adaptor.hpp │ │ │ │ │ │ ├── ordered_associative_container_adaptor.hpp │ │ │ │ │ │ ├── sequence_container_adaptor.hpp │ │ │ │ │ │ ├── set_adaptor.hpp │ │ │ │ │ │ ├── support/ │ │ │ │ │ │ │ └── iterator_facade_converters.hpp │ │ │ │ │ │ ├── unordered_associative_container_adaptor.hpp │ │ │ │ │ │ ├── unordered_map_adaptor.hpp │ │ │ │ │ │ ├── unordered_multimap_adaptor.hpp │ │ │ │ │ │ ├── unordered_multiset_adaptor.hpp │ │ │ │ │ │ ├── unordered_set_adaptor.hpp │ │ │ │ │ │ ├── vector_adaptor.hpp │ │ │ │ │ │ └── vector_map_adaptor.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── bimap_core.hpp │ │ │ │ │ │ ├── concept_tags.hpp │ │ │ │ │ │ ├── debug/ │ │ │ │ │ │ │ └── static_error.hpp │ │ │ │ │ │ ├── generate_index_binder.hpp │ │ │ │ │ │ ├── generate_relation_binder.hpp │ │ │ │ │ │ ├── generate_view_binder.hpp │ │ │ │ │ │ ├── is_set_type_of.hpp │ │ │ │ │ │ ├── manage_additional_parameters.hpp │ │ │ │ │ │ ├── manage_bimap_key.hpp │ │ │ │ │ │ ├── map_view_base.hpp │ │ │ │ │ │ ├── map_view_iterator.hpp │ │ │ │ │ │ ├── modifier_adaptor.hpp │ │ │ │ │ │ ├── non_unique_views_helper.hpp │ │ │ │ │ │ ├── set_view_base.hpp │ │ │ │ │ │ ├── set_view_iterator.hpp │ │ │ │ │ │ ├── test/ │ │ │ │ │ │ │ └── check_metadata.hpp │ │ │ │ │ │ └── user_interface_config.hpp │ │ │ │ │ ├── list_of.hpp │ │ │ │ │ ├── multiset_of.hpp │ │ │ │ │ ├── property_map/ │ │ │ │ │ │ ├── set_support.hpp │ │ │ │ │ │ └── unordered_set_support.hpp │ │ │ │ │ ├── relation/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── access_builder.hpp │ │ │ │ │ │ │ ├── metadata_access_builder.hpp │ │ │ │ │ │ │ ├── mutant.hpp │ │ │ │ │ │ │ ├── static_access_builder.hpp │ │ │ │ │ │ │ └── to_mutable_relation_functor.hpp │ │ │ │ │ │ ├── member_at.hpp │ │ │ │ │ │ ├── mutant_relation.hpp │ │ │ │ │ │ ├── pair_layout.hpp │ │ │ │ │ │ ├── structured_pair.hpp │ │ │ │ │ │ ├── support/ │ │ │ │ │ │ │ ├── data_extractor.hpp │ │ │ │ │ │ │ ├── get.hpp │ │ │ │ │ │ │ ├── get_pair_functor.hpp │ │ │ │ │ │ │ ├── is_tag_of_member_at.hpp │ │ │ │ │ │ │ ├── member_with_tag.hpp │ │ │ │ │ │ │ ├── opposite_tag.hpp │ │ │ │ │ │ │ ├── pair_by.hpp │ │ │ │ │ │ │ ├── pair_type_by.hpp │ │ │ │ │ │ │ └── value_type_of.hpp │ │ │ │ │ │ └── symmetrical_base.hpp │ │ │ │ │ ├── set_of.hpp │ │ │ │ │ ├── support/ │ │ │ │ │ │ ├── data_type_by.hpp │ │ │ │ │ │ ├── iterator_type_by.hpp │ │ │ │ │ │ ├── key_type_by.hpp │ │ │ │ │ │ ├── lambda.hpp │ │ │ │ │ │ ├── map_by.hpp │ │ │ │ │ │ ├── map_type_by.hpp │ │ │ │ │ │ └── value_type_by.hpp │ │ │ │ │ ├── tags/ │ │ │ │ │ │ ├── support/ │ │ │ │ │ │ │ ├── apply_to_value_type.hpp │ │ │ │ │ │ │ ├── default_tagged.hpp │ │ │ │ │ │ │ ├── is_tagged.hpp │ │ │ │ │ │ │ ├── overwrite_tagged.hpp │ │ │ │ │ │ │ ├── tag_of.hpp │ │ │ │ │ │ │ └── value_type_of.hpp │ │ │ │ │ │ └── tagged.hpp │ │ │ │ │ ├── unconstrained_set_of.hpp │ │ │ │ │ ├── unordered_multiset_of.hpp │ │ │ │ │ ├── unordered_set_of.hpp │ │ │ │ │ ├── vector_of.hpp │ │ │ │ │ └── views/ │ │ │ │ │ ├── list_map_view.hpp │ │ │ │ │ ├── list_set_view.hpp │ │ │ │ │ ├── map_view.hpp │ │ │ │ │ ├── multimap_view.hpp │ │ │ │ │ ├── multiset_view.hpp │ │ │ │ │ ├── set_view.hpp │ │ │ │ │ ├── unconstrained_map_view.hpp │ │ │ │ │ ├── unconstrained_set_view.hpp │ │ │ │ │ ├── unordered_map_view.hpp │ │ │ │ │ ├── unordered_multimap_view.hpp │ │ │ │ │ ├── unordered_multiset_view.hpp │ │ │ │ │ ├── unordered_set_view.hpp │ │ │ │ │ ├── vector_map_view.hpp │ │ │ │ │ └── vector_set_view.hpp │ │ │ │ ├── bimap.hpp │ │ │ │ ├── bind/ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ ├── arg.hpp │ │ │ │ │ ├── bind.hpp │ │ │ │ │ ├── bind_cc.hpp │ │ │ │ │ ├── bind_mf2_cc.hpp │ │ │ │ │ ├── bind_mf_cc.hpp │ │ │ │ │ ├── bind_template.hpp │ │ │ │ │ ├── make_adaptable.hpp │ │ │ │ │ ├── mem_fn.hpp │ │ │ │ │ ├── mem_fn_cc.hpp │ │ │ │ │ ├── mem_fn_template.hpp │ │ │ │ │ ├── mem_fn_vw.hpp │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ ├── protect.hpp │ │ │ │ │ └── storage.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── blank.hpp │ │ │ │ ├── blank_fwd.hpp │ │ │ │ ├── call_traits.hpp │ │ │ │ ├── cast.hpp │ │ │ │ ├── cerrno.hpp │ │ │ │ ├── checked_delete.hpp │ │ │ │ ├── chrono/ │ │ │ │ │ ├── ceil.hpp │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ ├── chrono_io.hpp │ │ │ │ │ ├── clock_string.hpp │ │ │ │ │ ├── config.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── inlined/ │ │ │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ │ │ ├── mac/ │ │ │ │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ │ │ │ └── thread_clock.hpp │ │ │ │ │ │ │ ├── posix/ │ │ │ │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ │ │ │ └── thread_clock.hpp │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ │ │ ├── thread_clock.hpp │ │ │ │ │ │ │ └── win/ │ │ │ │ │ │ │ ├── chrono.hpp │ │ │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ │ │ └── thread_clock.hpp │ │ │ │ │ │ ├── is_evenly_divisible_by.hpp │ │ │ │ │ │ ├── no_warning/ │ │ │ │ │ │ │ └── signed_unsigned_cmp.hpp │ │ │ │ │ │ ├── scan_keyword.hpp │ │ │ │ │ │ ├── static_assert.hpp │ │ │ │ │ │ └── system.hpp │ │ │ │ │ ├── duration.hpp │ │ │ │ │ ├── floor.hpp │ │ │ │ │ ├── include.hpp │ │ │ │ │ ├── io/ │ │ │ │ │ │ ├── duration_get.hpp │ │ │ │ │ │ ├── duration_io.hpp │ │ │ │ │ │ ├── duration_put.hpp │ │ │ │ │ │ ├── duration_style.hpp │ │ │ │ │ │ ├── duration_units.hpp │ │ │ │ │ │ ├── ios_base_state.hpp │ │ │ │ │ │ ├── time_point_get.hpp │ │ │ │ │ │ ├── time_point_io.hpp │ │ │ │ │ │ ├── time_point_put.hpp │ │ │ │ │ │ ├── time_point_units.hpp │ │ │ │ │ │ ├── timezone.hpp │ │ │ │ │ │ └── utility/ │ │ │ │ │ │ ├── ios_base_state_ptr.hpp │ │ │ │ │ │ ├── manip_base.hpp │ │ │ │ │ │ └── to_string.hpp │ │ │ │ │ ├── io_v1/ │ │ │ │ │ │ └── chrono_io.hpp │ │ │ │ │ ├── process_cpu_clocks.hpp │ │ │ │ │ ├── round.hpp │ │ │ │ │ ├── system_clocks.hpp │ │ │ │ │ ├── thread_clock.hpp │ │ │ │ │ ├── time_point.hpp │ │ │ │ │ └── typeof/ │ │ │ │ │ └── boost/ │ │ │ │ │ ├── chrono/ │ │ │ │ │ │ └── chrono.hpp │ │ │ │ │ └── ratio.hpp │ │ │ │ ├── chrono.hpp │ │ │ │ ├── circular_buffer/ │ │ │ │ │ ├── base.hpp │ │ │ │ │ ├── debug.hpp │ │ │ │ │ ├── details.hpp │ │ │ │ │ └── space_optimized.hpp │ │ │ │ ├── circular_buffer.hpp │ │ │ │ ├── circular_buffer_fwd.hpp │ │ │ │ ├── compatibility/ │ │ │ │ │ └── cpp_c_headers/ │ │ │ │ │ ├── cassert │ │ │ │ │ ├── cctype │ │ │ │ │ ├── cerrno │ │ │ │ │ ├── cfloat │ │ │ │ │ ├── climits │ │ │ │ │ ├── clocale │ │ │ │ │ ├── cmath │ │ │ │ │ ├── csetjmp │ │ │ │ │ ├── csignal │ │ │ │ │ ├── cstdarg │ │ │ │ │ ├── cstddef │ │ │ │ │ ├── cstdio │ │ │ │ │ ├── cstdlib │ │ │ │ │ ├── cstring │ │ │ │ │ ├── ctime │ │ │ │ │ ├── cwchar │ │ │ │ │ └── cwctype │ │ │ │ ├── compressed_pair.hpp │ │ │ │ ├── compute/ │ │ │ │ │ ├── algorithm/ │ │ │ │ │ │ ├── accumulate.hpp │ │ │ │ │ │ ├── adjacent_difference.hpp │ │ │ │ │ │ ├── adjacent_find.hpp │ │ │ │ │ │ ├── all_of.hpp │ │ │ │ │ │ ├── any_of.hpp │ │ │ │ │ │ ├── binary_search.hpp │ │ │ │ │ │ ├── copy.hpp │ │ │ │ │ │ ├── copy_if.hpp │ │ │ │ │ │ ├── copy_n.hpp │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ ├── count_if.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── balanced_path.hpp │ │ │ │ │ │ │ ├── binary_find.hpp │ │ │ │ │ │ │ ├── compact.hpp │ │ │ │ │ │ │ ├── copy_on_device.hpp │ │ │ │ │ │ │ ├── copy_to_device.hpp │ │ │ │ │ │ │ ├── copy_to_host.hpp │ │ │ │ │ │ │ ├── count_if_with_ballot.hpp │ │ │ │ │ │ │ ├── count_if_with_reduce.hpp │ │ │ │ │ │ │ ├── count_if_with_threads.hpp │ │ │ │ │ │ │ ├── find_extrema.hpp │ │ │ │ │ │ │ ├── find_extrema_on_cpu.hpp │ │ │ │ │ │ │ ├── find_extrema_with_atomics.hpp │ │ │ │ │ │ │ ├── find_extrema_with_reduce.hpp │ │ │ │ │ │ │ ├── find_if_with_atomics.hpp │ │ │ │ │ │ │ ├── inplace_reduce.hpp │ │ │ │ │ │ │ ├── insertion_sort.hpp │ │ │ │ │ │ │ ├── merge_path.hpp │ │ │ │ │ │ │ ├── merge_sort_on_cpu.hpp │ │ │ │ │ │ │ ├── merge_sort_on_gpu.hpp │ │ │ │ │ │ │ ├── merge_with_merge_path.hpp │ │ │ │ │ │ │ ├── radix_sort.hpp │ │ │ │ │ │ │ ├── random_fill.hpp │ │ │ │ │ │ │ ├── reduce_by_key.hpp │ │ │ │ │ │ │ ├── reduce_by_key_with_scan.hpp │ │ │ │ │ │ │ ├── reduce_on_cpu.hpp │ │ │ │ │ │ │ ├── reduce_on_gpu.hpp │ │ │ │ │ │ │ ├── scan.hpp │ │ │ │ │ │ │ ├── scan_on_cpu.hpp │ │ │ │ │ │ │ ├── scan_on_gpu.hpp │ │ │ │ │ │ │ ├── search_all.hpp │ │ │ │ │ │ │ ├── serial_accumulate.hpp │ │ │ │ │ │ │ ├── serial_count_if.hpp │ │ │ │ │ │ │ ├── serial_find_extrema.hpp │ │ │ │ │ │ │ ├── serial_merge.hpp │ │ │ │ │ │ │ ├── serial_reduce.hpp │ │ │ │ │ │ │ ├── serial_reduce_by_key.hpp │ │ │ │ │ │ │ └── serial_scan.hpp │ │ │ │ │ │ ├── equal.hpp │ │ │ │ │ │ ├── equal_range.hpp │ │ │ │ │ │ ├── exclusive_scan.hpp │ │ │ │ │ │ ├── fill.hpp │ │ │ │ │ │ ├── fill_n.hpp │ │ │ │ │ │ ├── find.hpp │ │ │ │ │ │ ├── find_end.hpp │ │ │ │ │ │ ├── find_if.hpp │ │ │ │ │ │ ├── find_if_not.hpp │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ ├── for_each_n.hpp │ │ │ │ │ │ ├── gather.hpp │ │ │ │ │ │ ├── generate.hpp │ │ │ │ │ │ ├── generate_n.hpp │ │ │ │ │ │ ├── includes.hpp │ │ │ │ │ │ ├── inclusive_scan.hpp │ │ │ │ │ │ ├── inner_product.hpp │ │ │ │ │ │ ├── inplace_merge.hpp │ │ │ │ │ │ ├── iota.hpp │ │ │ │ │ │ ├── is_partitioned.hpp │ │ │ │ │ │ ├── is_permutation.hpp │ │ │ │ │ │ ├── is_sorted.hpp │ │ │ │ │ │ ├── lexicographical_compare.hpp │ │ │ │ │ │ ├── lower_bound.hpp │ │ │ │ │ │ ├── max_element.hpp │ │ │ │ │ │ ├── merge.hpp │ │ │ │ │ │ ├── min_element.hpp │ │ │ │ │ │ ├── minmax_element.hpp │ │ │ │ │ │ ├── mismatch.hpp │ │ │ │ │ │ ├── next_permutation.hpp │ │ │ │ │ │ ├── none_of.hpp │ │ │ │ │ │ ├── nth_element.hpp │ │ │ │ │ │ ├── partial_sum.hpp │ │ │ │ │ │ ├── partition.hpp │ │ │ │ │ │ ├── partition_copy.hpp │ │ │ │ │ │ ├── partition_point.hpp │ │ │ │ │ │ ├── prev_permutation.hpp │ │ │ │ │ │ ├── random_shuffle.hpp │ │ │ │ │ │ ├── reduce.hpp │ │ │ │ │ │ ├── reduce_by_key.hpp │ │ │ │ │ │ ├── remove.hpp │ │ │ │ │ │ ├── remove_if.hpp │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ ├── replace_copy.hpp │ │ │ │ │ │ ├── reverse.hpp │ │ │ │ │ │ ├── reverse_copy.hpp │ │ │ │ │ │ ├── rotate.hpp │ │ │ │ │ │ ├── rotate_copy.hpp │ │ │ │ │ │ ├── scatter.hpp │ │ │ │ │ │ ├── scatter_if.hpp │ │ │ │ │ │ ├── search.hpp │ │ │ │ │ │ ├── search_n.hpp │ │ │ │ │ │ ├── set_difference.hpp │ │ │ │ │ │ ├── set_intersection.hpp │ │ │ │ │ │ ├── set_symmetric_difference.hpp │ │ │ │ │ │ ├── set_union.hpp │ │ │ │ │ │ ├── sort.hpp │ │ │ │ │ │ ├── sort_by_key.hpp │ │ │ │ │ │ ├── stable_partition.hpp │ │ │ │ │ │ ├── stable_sort.hpp │ │ │ │ │ │ ├── stable_sort_by_key.hpp │ │ │ │ │ │ ├── swap_ranges.hpp │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ ├── transform_if.hpp │ │ │ │ │ │ ├── transform_reduce.hpp │ │ │ │ │ │ ├── unique.hpp │ │ │ │ │ │ ├── unique_copy.hpp │ │ │ │ │ │ └── upper_bound.hpp │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── allocator/ │ │ │ │ │ │ ├── buffer_allocator.hpp │ │ │ │ │ │ └── pinned_allocator.hpp │ │ │ │ │ ├── allocator.hpp │ │ │ │ │ ├── async/ │ │ │ │ │ │ ├── future.hpp │ │ │ │ │ │ ├── wait.hpp │ │ │ │ │ │ └── wait_guard.hpp │ │ │ │ │ ├── async.hpp │ │ │ │ │ ├── buffer.hpp │ │ │ │ │ ├── cl.hpp │ │ │ │ │ ├── cl_ext.hpp │ │ │ │ │ ├── closure.hpp │ │ │ │ │ ├── command_queue.hpp │ │ │ │ │ ├── config.hpp │ │ │ │ │ ├── container/ │ │ │ │ │ │ ├── array.hpp │ │ │ │ │ │ ├── basic_string.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── scalar.hpp │ │ │ │ │ │ ├── dynamic_bitset.hpp │ │ │ │ │ │ ├── flat_map.hpp │ │ │ │ │ │ ├── flat_set.hpp │ │ │ │ │ │ ├── mapped_view.hpp │ │ │ │ │ │ ├── stack.hpp │ │ │ │ │ │ ├── string.hpp │ │ │ │ │ │ ├── valarray.hpp │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ ├── container.hpp │ │ │ │ │ ├── context.hpp │ │ │ │ │ ├── core.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── assert_cl_success.hpp │ │ │ │ │ │ ├── buffer_value.hpp │ │ │ │ │ │ ├── device_ptr.hpp │ │ │ │ │ │ ├── diagnostic.hpp │ │ │ │ │ │ ├── duration.hpp │ │ │ │ │ │ ├── get_object_info.hpp │ │ │ │ │ │ ├── getenv.hpp │ │ │ │ │ │ ├── global_static.hpp │ │ │ │ │ │ ├── is_buffer_iterator.hpp │ │ │ │ │ │ ├── is_contiguous_iterator.hpp │ │ │ │ │ │ ├── iterator_plus_distance.hpp │ │ │ │ │ │ ├── iterator_range_size.hpp │ │ │ │ │ │ ├── iterator_traits.hpp │ │ │ │ │ │ ├── literal.hpp │ │ │ │ │ │ ├── lru_cache.hpp │ │ │ │ │ │ ├── meta_kernel.hpp │ │ │ │ │ │ ├── mpl_vector_to_tuple.hpp │ │ │ │ │ │ ├── nvidia_compute_capability.hpp │ │ │ │ │ │ ├── parameter_cache.hpp │ │ │ │ │ │ ├── path.hpp │ │ │ │ │ │ ├── print_range.hpp │ │ │ │ │ │ ├── read_write_single_value.hpp │ │ │ │ │ │ ├── sha1.hpp │ │ │ │ │ │ ├── variadic_macros.hpp │ │ │ │ │ │ ├── vendor.hpp │ │ │ │ │ │ └── work_size.hpp │ │ │ │ │ ├── device.hpp │ │ │ │ │ ├── event.hpp │ │ │ │ │ ├── exception/ │ │ │ │ │ │ ├── context_error.hpp │ │ │ │ │ │ ├── no_device_found.hpp │ │ │ │ │ │ ├── opencl_error.hpp │ │ │ │ │ │ └── unsupported_extension_error.hpp │ │ │ │ │ ├── exception.hpp │ │ │ │ │ ├── experimental/ │ │ │ │ │ │ ├── clamp_range.hpp │ │ │ │ │ │ ├── malloc.hpp │ │ │ │ │ │ ├── sort_by_transform.hpp │ │ │ │ │ │ └── tabulate.hpp │ │ │ │ │ ├── function.hpp │ │ │ │ │ ├── functional/ │ │ │ │ │ │ ├── as.hpp │ │ │ │ │ │ ├── atomic.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── common.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── macros.hpp │ │ │ │ │ │ │ ├── nvidia_ballot.hpp │ │ │ │ │ │ │ ├── nvidia_popcount.hpp │ │ │ │ │ │ │ └── unpack.hpp │ │ │ │ │ │ ├── field.hpp │ │ │ │ │ │ ├── geometry.hpp │ │ │ │ │ │ ├── get.hpp │ │ │ │ │ │ ├── hash.hpp │ │ │ │ │ │ ├── identity.hpp │ │ │ │ │ │ ├── integer.hpp │ │ │ │ │ │ ├── logical.hpp │ │ │ │ │ │ ├── math.hpp │ │ │ │ │ │ ├── operator.hpp │ │ │ │ │ │ ├── popcount.hpp │ │ │ │ │ │ └── relational.hpp │ │ │ │ │ ├── functional.hpp │ │ │ │ │ ├── image/ │ │ │ │ │ │ ├── image1d.hpp │ │ │ │ │ │ ├── image2d.hpp │ │ │ │ │ │ ├── image3d.hpp │ │ │ │ │ │ ├── image_format.hpp │ │ │ │ │ │ ├── image_object.hpp │ │ │ │ │ │ └── image_sampler.hpp │ │ │ │ │ ├── image.hpp │ │ │ │ │ ├── image2d.hpp │ │ │ │ │ ├── image3d.hpp │ │ │ │ │ ├── image_format.hpp │ │ │ │ │ ├── image_sampler.hpp │ │ │ │ │ ├── interop/ │ │ │ │ │ │ ├── eigen/ │ │ │ │ │ │ │ └── core.hpp │ │ │ │ │ │ ├── eigen.hpp │ │ │ │ │ │ ├── opencv/ │ │ │ │ │ │ │ ├── core.hpp │ │ │ │ │ │ │ ├── highgui.hpp │ │ │ │ │ │ │ └── ocl.hpp │ │ │ │ │ │ ├── opencv.hpp │ │ │ │ │ │ ├── opengl/ │ │ │ │ │ │ │ ├── acquire.hpp │ │ │ │ │ │ │ ├── cl_gl.hpp │ │ │ │ │ │ │ ├── cl_gl_ext.hpp │ │ │ │ │ │ │ ├── context.hpp │ │ │ │ │ │ │ ├── gl.hpp │ │ │ │ │ │ │ ├── opengl_buffer.hpp │ │ │ │ │ │ │ ├── opengl_renderbuffer.hpp │ │ │ │ │ │ │ └── opengl_texture.hpp │ │ │ │ │ │ ├── opengl.hpp │ │ │ │ │ │ ├── qt/ │ │ │ │ │ │ │ ├── qimage.hpp │ │ │ │ │ │ │ ├── qpoint.hpp │ │ │ │ │ │ │ ├── qpointf.hpp │ │ │ │ │ │ │ ├── qtcore.hpp │ │ │ │ │ │ │ ├── qtgui.hpp │ │ │ │ │ │ │ └── qvector.hpp │ │ │ │ │ │ ├── qt.hpp │ │ │ │ │ │ ├── vtk/ │ │ │ │ │ │ │ ├── bounds.hpp │ │ │ │ │ │ │ ├── data_array.hpp │ │ │ │ │ │ │ ├── matrix4x4.hpp │ │ │ │ │ │ │ └── points.hpp │ │ │ │ │ │ └── vtk.hpp │ │ │ │ │ ├── iterator/ │ │ │ │ │ │ ├── buffer_iterator.hpp │ │ │ │ │ │ ├── constant_buffer_iterator.hpp │ │ │ │ │ │ ├── constant_iterator.hpp │ │ │ │ │ │ ├── counting_iterator.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── get_base_iterator_buffer.hpp │ │ │ │ │ │ │ └── swizzle_iterator.hpp │ │ │ │ │ │ ├── discard_iterator.hpp │ │ │ │ │ │ ├── function_input_iterator.hpp │ │ │ │ │ │ ├── permutation_iterator.hpp │ │ │ │ │ │ ├── strided_iterator.hpp │ │ │ │ │ │ ├── transform_iterator.hpp │ │ │ │ │ │ └── zip_iterator.hpp │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ ├── kernel.hpp │ │ │ │ │ ├── lambda/ │ │ │ │ │ │ ├── context.hpp │ │ │ │ │ │ ├── functional.hpp │ │ │ │ │ │ ├── get.hpp │ │ │ │ │ │ ├── make_pair.hpp │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ ├── placeholder.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ └── result_of.hpp │ │ │ │ │ ├── lambda.hpp │ │ │ │ │ ├── memory/ │ │ │ │ │ │ ├── local_buffer.hpp │ │ │ │ │ │ └── svm_ptr.hpp │ │ │ │ │ ├── memory.hpp │ │ │ │ │ ├── memory_object.hpp │ │ │ │ │ ├── pipe.hpp │ │ │ │ │ ├── platform.hpp │ │ │ │ │ ├── program.hpp │ │ │ │ │ ├── random/ │ │ │ │ │ │ ├── bernoulli_distribution.hpp │ │ │ │ │ │ ├── default_random_engine.hpp │ │ │ │ │ │ ├── discrete_distribution.hpp │ │ │ │ │ │ ├── linear_congruential_engine.hpp │ │ │ │ │ │ ├── mersenne_twister_engine.hpp │ │ │ │ │ │ ├── normal_distribution.hpp │ │ │ │ │ │ ├── threefry_engine.hpp │ │ │ │ │ │ ├── uniform_int_distribution.hpp │ │ │ │ │ │ └── uniform_real_distribution.hpp │ │ │ │ │ ├── random.hpp │ │ │ │ │ ├── source.hpp │ │ │ │ │ ├── svm.hpp │ │ │ │ │ ├── system.hpp │ │ │ │ │ ├── type_traits/ │ │ │ │ │ │ ├── common_type.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── capture_traits.hpp │ │ │ │ │ │ ├── is_device_iterator.hpp │ │ │ │ │ │ ├── is_fundamental.hpp │ │ │ │ │ │ ├── is_vector_type.hpp │ │ │ │ │ │ ├── make_vector_type.hpp │ │ │ │ │ │ ├── result_of.hpp │ │ │ │ │ │ ├── scalar_type.hpp │ │ │ │ │ │ ├── type_definition.hpp │ │ │ │ │ │ ├── type_name.hpp │ │ │ │ │ │ └── vector_size.hpp │ │ │ │ │ ├── type_traits.hpp │ │ │ │ │ ├── types/ │ │ │ │ │ │ ├── builtin.hpp │ │ │ │ │ │ ├── complex.hpp │ │ │ │ │ │ ├── fundamental.hpp │ │ │ │ │ │ ├── pair.hpp │ │ │ │ │ │ ├── struct.hpp │ │ │ │ │ │ └── tuple.hpp │ │ │ │ │ ├── types.hpp │ │ │ │ │ ├── user_event.hpp │ │ │ │ │ ├── utility/ │ │ │ │ │ │ ├── dim.hpp │ │ │ │ │ │ ├── extents.hpp │ │ │ │ │ │ ├── invoke.hpp │ │ │ │ │ │ ├── program_cache.hpp │ │ │ │ │ │ ├── source.hpp │ │ │ │ │ │ └── wait_list.hpp │ │ │ │ │ ├── utility.hpp │ │ │ │ │ ├── version.hpp │ │ │ │ │ └── wait_list.hpp │ │ │ │ ├── compute.hpp │ │ │ │ ├── concept/ │ │ │ │ │ ├── assert.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── backward_compatibility.hpp │ │ │ │ │ │ ├── borland.hpp │ │ │ │ │ │ ├── concept_def.hpp │ │ │ │ │ │ ├── concept_undef.hpp │ │ │ │ │ │ ├── general.hpp │ │ │ │ │ │ ├── has_constraints.hpp │ │ │ │ │ │ └── msvc.hpp │ │ │ │ │ ├── requires.hpp │ │ │ │ │ └── usage.hpp │ │ │ │ ├── concept_archetype.hpp │ │ │ │ ├── concept_check/ │ │ │ │ │ ├── borland.hpp │ │ │ │ │ ├── general.hpp │ │ │ │ │ ├── has_constraints.hpp │ │ │ │ │ └── msvc.hpp │ │ │ │ ├── concept_check.hpp │ │ │ │ ├── config/ │ │ │ │ │ ├── abi/ │ │ │ │ │ │ ├── borland_prefix.hpp │ │ │ │ │ │ ├── borland_suffix.hpp │ │ │ │ │ │ ├── msvc_prefix.hpp │ │ │ │ │ │ └── msvc_suffix.hpp │ │ │ │ │ ├── abi_prefix.hpp │ │ │ │ │ ├── abi_suffix.hpp │ │ │ │ │ ├── auto_link.hpp │ │ │ │ │ ├── compiler/ │ │ │ │ │ │ ├── borland.hpp │ │ │ │ │ │ ├── clang.hpp │ │ │ │ │ │ ├── codegear.hpp │ │ │ │ │ │ ├── comeau.hpp │ │ │ │ │ │ ├── common_edg.hpp │ │ │ │ │ │ ├── compaq_cxx.hpp │ │ │ │ │ │ ├── cray.hpp │ │ │ │ │ │ ├── digitalmars.hpp │ │ │ │ │ │ ├── gcc.hpp │ │ │ │ │ │ ├── gcc_xml.hpp │ │ │ │ │ │ ├── greenhills.hpp │ │ │ │ │ │ ├── hp_acc.hpp │ │ │ │ │ │ ├── intel.hpp │ │ │ │ │ │ ├── kai.hpp │ │ │ │ │ │ ├── metrowerks.hpp │ │ │ │ │ │ ├── mpw.hpp │ │ │ │ │ │ ├── nvcc.hpp │ │ │ │ │ │ ├── pathscale.hpp │ │ │ │ │ │ ├── pgi.hpp │ │ │ │ │ │ ├── sgi_mipspro.hpp │ │ │ │ │ │ ├── sunpro_cc.hpp │ │ │ │ │ │ ├── vacpp.hpp │ │ │ │ │ │ ├── visualc.hpp │ │ │ │ │ │ └── xlcpp.hpp │ │ │ │ │ ├── no_tr1/ │ │ │ │ │ │ ├── cmath.hpp │ │ │ │ │ │ ├── complex.hpp │ │ │ │ │ │ ├── functional.hpp │ │ │ │ │ │ ├── memory.hpp │ │ │ │ │ │ └── utility.hpp │ │ │ │ │ ├── platform/ │ │ │ │ │ │ ├── aix.hpp │ │ │ │ │ │ ├── amigaos.hpp │ │ │ │ │ │ ├── beos.hpp │ │ │ │ │ │ ├── bsd.hpp │ │ │ │ │ │ ├── cloudabi.hpp │ │ │ │ │ │ ├── cray.hpp │ │ │ │ │ │ ├── cygwin.hpp │ │ │ │ │ │ ├── haiku.hpp │ │ │ │ │ │ ├── hpux.hpp │ │ │ │ │ │ ├── irix.hpp │ │ │ │ │ │ ├── linux.hpp │ │ │ │ │ │ ├── macos.hpp │ │ │ │ │ │ ├── qnxnto.hpp │ │ │ │ │ │ ├── solaris.hpp │ │ │ │ │ │ ├── symbian.hpp │ │ │ │ │ │ ├── vms.hpp │ │ │ │ │ │ ├── vxworks.hpp │ │ │ │ │ │ └── win32.hpp │ │ │ │ │ ├── posix_features.hpp │ │ │ │ │ ├── requires_threads.hpp │ │ │ │ │ ├── select_compiler_config.hpp │ │ │ │ │ ├── select_platform_config.hpp │ │ │ │ │ ├── select_stdlib_config.hpp │ │ │ │ │ ├── stdlib/ │ │ │ │ │ │ ├── dinkumware.hpp │ │ │ │ │ │ ├── libcomo.hpp │ │ │ │ │ │ ├── libcpp.hpp │ │ │ │ │ │ ├── libstdcpp3.hpp │ │ │ │ │ │ ├── modena.hpp │ │ │ │ │ │ ├── msl.hpp │ │ │ │ │ │ ├── roguewave.hpp │ │ │ │ │ │ ├── sgi.hpp │ │ │ │ │ │ ├── stlport.hpp │ │ │ │ │ │ └── vacpp.hpp │ │ │ │ │ ├── suffix.hpp │ │ │ │ │ ├── user.hpp │ │ │ │ │ └── warning_disable.hpp │ │ │ │ ├── config.hpp │ │ │ │ ├── container/ │ │ │ │ │ ├── adaptive_pool.hpp │ │ │ │ │ ├── allocator.hpp │ │ │ │ │ ├── allocator_traits.hpp │ │ │ │ │ ├── container_fwd.hpp │ │ │ │ │ ├── deque.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── adaptive_node_pool.hpp │ │ │ │ │ │ ├── adaptive_node_pool_impl.hpp │ │ │ │ │ │ ├── addressof.hpp │ │ │ │ │ │ ├── advanced_insert_int.hpp │ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ │ ├── algorithms.hpp │ │ │ │ │ │ ├── alloc_helpers.hpp │ │ │ │ │ │ ├── alloc_lib.h │ │ │ │ │ │ ├── alloc_lib_auto_link.hpp │ │ │ │ │ │ ├── allocation_type.hpp │ │ │ │ │ │ ├── allocator_version_traits.hpp │ │ │ │ │ │ ├── auto_link.hpp │ │ │ │ │ │ ├── block_list.hpp │ │ │ │ │ │ ├── block_slist.hpp │ │ │ │ │ │ ├── compare_functors.hpp │ │ │ │ │ │ ├── config_begin.hpp │ │ │ │ │ │ ├── config_end.hpp │ │ │ │ │ │ ├── construct_in_place.hpp │ │ │ │ │ │ ├── copy_move_algo.hpp │ │ │ │ │ │ ├── destroyers.hpp │ │ │ │ │ │ ├── dispatch_uses_allocator.hpp │ │ │ │ │ │ ├── dlmalloc.hpp │ │ │ │ │ │ ├── flat_tree.hpp │ │ │ │ │ │ ├── function_detector.hpp │ │ │ │ │ │ ├── hash_table.hpp │ │ │ │ │ │ ├── is_sorted.hpp │ │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ │ ├── iterator_to_raw_pointer.hpp │ │ │ │ │ │ ├── iterators.hpp │ │ │ │ │ │ ├── math_functions.hpp │ │ │ │ │ │ ├── memory_util.hpp │ │ │ │ │ │ ├── min_max.hpp │ │ │ │ │ │ ├── minimal_char_traits_header.hpp │ │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ │ ├── multiallocation_chain.hpp │ │ │ │ │ │ ├── mutex.hpp │ │ │ │ │ │ ├── next_capacity.hpp │ │ │ │ │ │ ├── node_alloc_holder.hpp │ │ │ │ │ │ ├── node_pool.hpp │ │ │ │ │ │ ├── node_pool_impl.hpp │ │ │ │ │ │ ├── pair.hpp │ │ │ │ │ │ ├── placement_new.hpp │ │ │ │ │ │ ├── pool_common.hpp │ │ │ │ │ │ ├── pool_common_alloc.hpp │ │ │ │ │ │ ├── pool_resource.hpp │ │ │ │ │ │ ├── preprocessor.hpp │ │ │ │ │ │ ├── singleton.hpp │ │ │ │ │ │ ├── std_fwd.hpp │ │ │ │ │ │ ├── to_raw_pointer.hpp │ │ │ │ │ │ ├── transform_iterator.hpp │ │ │ │ │ │ ├── tree.hpp │ │ │ │ │ │ ├── type_traits.hpp │ │ │ │ │ │ ├── utilities.hpp │ │ │ │ │ │ ├── value_init.hpp │ │ │ │ │ │ ├── variadic_templates_tools.hpp │ │ │ │ │ │ ├── version_type.hpp │ │ │ │ │ │ └── workaround.hpp │ │ │ │ │ ├── flat_map.hpp │ │ │ │ │ ├── flat_set.hpp │ │ │ │ │ ├── list.hpp │ │ │ │ │ ├── map.hpp │ │ │ │ │ ├── new_allocator.hpp │ │ │ │ │ ├── node_allocator.hpp │ │ │ │ │ ├── node_handle.hpp │ │ │ │ │ ├── options.hpp │ │ │ │ │ ├── pmr/ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── flat_map.hpp │ │ │ │ │ │ ├── flat_set.hpp │ │ │ │ │ │ ├── global_resource.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── memory_resource.hpp │ │ │ │ │ │ ├── monotonic_buffer_resource.hpp │ │ │ │ │ │ ├── polymorphic_allocator.hpp │ │ │ │ │ │ ├── pool_options.hpp │ │ │ │ │ │ ├── resource_adaptor.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── slist.hpp │ │ │ │ │ │ ├── small_vector.hpp │ │ │ │ │ │ ├── stable_vector.hpp │ │ │ │ │ │ ├── string.hpp │ │ │ │ │ │ ├── synchronized_pool_resource.hpp │ │ │ │ │ │ ├── unsynchronized_pool_resource.hpp │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ ├── scoped_allocator.hpp │ │ │ │ │ ├── scoped_allocator_fwd.hpp │ │ │ │ │ ├── set.hpp │ │ │ │ │ ├── slist.hpp │ │ │ │ │ ├── small_vector.hpp │ │ │ │ │ ├── stable_vector.hpp │ │ │ │ │ ├── static_vector.hpp │ │ │ │ │ ├── string.hpp │ │ │ │ │ ├── throw_exception.hpp │ │ │ │ │ ├── uses_allocator.hpp │ │ │ │ │ ├── uses_allocator_fwd.hpp │ │ │ │ │ └── vector.hpp │ │ │ │ ├── context/ │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── disable_overload.hpp │ │ │ │ │ │ ├── exception.hpp │ │ │ │ │ │ ├── exchange.hpp │ │ │ │ │ │ ├── fcontext.hpp │ │ │ │ │ │ ├── fcontext_arm.hpp │ │ │ │ │ │ ├── fcontext_arm_mac.hpp │ │ │ │ │ │ ├── fcontext_arm_win.hpp │ │ │ │ │ │ ├── fcontext_i386.hpp │ │ │ │ │ │ ├── fcontext_i386_win.hpp │ │ │ │ │ │ ├── fcontext_mips.hpp │ │ │ │ │ │ ├── fcontext_ppc.hpp │ │ │ │ │ │ ├── fcontext_sparc.hpp │ │ │ │ │ │ ├── fcontext_x86_64.hpp │ │ │ │ │ │ ├── fcontext_x86_64_win.hpp │ │ │ │ │ │ ├── index_sequence.hpp │ │ │ │ │ │ ├── invoke.hpp │ │ │ │ │ │ └── tuple.hpp │ │ │ │ │ ├── execution_context.hpp │ │ │ │ │ ├── execution_context_v1.hpp │ │ │ │ │ ├── execution_context_v2.hpp │ │ │ │ │ ├── execution_context_v2_void.ipp │ │ │ │ │ ├── fcontext.hpp │ │ │ │ │ ├── fixedsize_stack.hpp │ │ │ │ │ ├── flags.hpp │ │ │ │ │ ├── pooled_fixedsize_stack.hpp │ │ │ │ │ ├── posix/ │ │ │ │ │ │ ├── protected_fixedsize_stack.hpp │ │ │ │ │ │ └── segmented_stack.hpp │ │ │ │ │ ├── preallocated.hpp │ │ │ │ │ ├── protected_fixedsize_stack.hpp │ │ │ │ │ ├── segmented_stack.hpp │ │ │ │ │ ├── stack_context.hpp │ │ │ │ │ ├── stack_traits.hpp │ │ │ │ │ └── windows/ │ │ │ │ │ └── protected_fixedsize_stack.hpp │ │ │ │ ├── convert/ │ │ │ │ │ ├── base.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── boost_parameter_ext.hpp │ │ │ │ │ │ ├── char.hpp │ │ │ │ │ │ ├── forward.hpp │ │ │ │ │ │ ├── has_member.hpp │ │ │ │ │ │ ├── is_callable.hpp │ │ │ │ │ │ ├── is_converter.hpp │ │ │ │ │ │ ├── is_fun.hpp │ │ │ │ │ │ ├── is_string.hpp │ │ │ │ │ │ └── range.hpp │ │ │ │ │ ├── lexical_cast.hpp │ │ │ │ │ ├── parameters.hpp │ │ │ │ │ ├── printf.hpp │ │ │ │ │ ├── spirit.hpp │ │ │ │ │ ├── stream.hpp │ │ │ │ │ └── strtol.hpp │ │ │ │ ├── convert.hpp │ │ │ │ ├── core/ │ │ │ │ │ ├── addressof.hpp │ │ │ │ │ ├── checked_delete.hpp │ │ │ │ │ ├── demangle.hpp │ │ │ │ │ ├── enable_if.hpp │ │ │ │ │ ├── explicit_operator_bool.hpp │ │ │ │ │ ├── ignore_unused.hpp │ │ │ │ │ ├── is_same.hpp │ │ │ │ │ ├── lightweight_test.hpp │ │ │ │ │ ├── lightweight_test_trait.hpp │ │ │ │ │ ├── no_exceptions_support.hpp │ │ │ │ │ ├── noncopyable.hpp │ │ │ │ │ ├── null_deleter.hpp │ │ │ │ │ ├── ref.hpp │ │ │ │ │ ├── scoped_enum.hpp │ │ │ │ │ ├── swap.hpp │ │ │ │ │ ├── typeinfo.hpp │ │ │ │ │ └── underlying_type.hpp │ │ │ │ ├── coroutine/ │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── asymmetric_coroutine.hpp │ │ │ │ │ ├── attributes.hpp │ │ │ │ │ ├── coroutine.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── coroutine_context.hpp │ │ │ │ │ │ ├── data.hpp │ │ │ │ │ │ ├── flags.hpp │ │ │ │ │ │ ├── parameters.hpp │ │ │ │ │ │ ├── preallocated.hpp │ │ │ │ │ │ ├── pull_coroutine_impl.hpp │ │ │ │ │ │ ├── pull_coroutine_object.hpp │ │ │ │ │ │ ├── pull_coroutine_synthesized.hpp │ │ │ │ │ │ ├── push_coroutine_impl.hpp │ │ │ │ │ │ ├── push_coroutine_object.hpp │ │ │ │ │ │ ├── push_coroutine_synthesized.hpp │ │ │ │ │ │ ├── setup.hpp │ │ │ │ │ │ ├── symmetric_coroutine_call.hpp │ │ │ │ │ │ ├── symmetric_coroutine_impl.hpp │ │ │ │ │ │ ├── symmetric_coroutine_object.hpp │ │ │ │ │ │ ├── symmetric_coroutine_yield.hpp │ │ │ │ │ │ ├── trampoline.hpp │ │ │ │ │ │ ├── trampoline_pull.hpp │ │ │ │ │ │ └── trampoline_push.hpp │ │ │ │ │ ├── exceptions.hpp │ │ │ │ │ ├── flags.hpp │ │ │ │ │ ├── posix/ │ │ │ │ │ │ ├── protected_stack_allocator.hpp │ │ │ │ │ │ └── segmented_stack_allocator.hpp │ │ │ │ │ ├── protected_stack_allocator.hpp │ │ │ │ │ ├── segmented_stack_allocator.hpp │ │ │ │ │ ├── stack_allocator.hpp │ │ │ │ │ ├── stack_context.hpp │ │ │ │ │ ├── stack_traits.hpp │ │ │ │ │ ├── standard_stack_allocator.hpp │ │ │ │ │ ├── symmetric_coroutine.hpp │ │ │ │ │ └── windows/ │ │ │ │ │ └── protected_stack_allocator.hpp │ │ │ │ ├── coroutine2/ │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── coroutine.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── coroutine.hpp │ │ │ │ │ │ ├── create_control_block.ipp │ │ │ │ │ │ ├── decay_copy.hpp │ │ │ │ │ │ ├── disable_overload.hpp │ │ │ │ │ │ ├── forced_unwind.hpp │ │ │ │ │ │ ├── pull_control_block_ecv1.hpp │ │ │ │ │ │ ├── pull_control_block_ecv1.ipp │ │ │ │ │ │ ├── pull_control_block_ecv2.hpp │ │ │ │ │ │ ├── pull_control_block_ecv2.ipp │ │ │ │ │ │ ├── pull_coroutine.hpp │ │ │ │ │ │ ├── pull_coroutine.ipp │ │ │ │ │ │ ├── push_control_block_ecv1.hpp │ │ │ │ │ │ ├── push_control_block_ecv1.ipp │ │ │ │ │ │ ├── push_control_block_ecv2.hpp │ │ │ │ │ │ ├── push_control_block_ecv2.ipp │ │ │ │ │ │ ├── push_coroutine.hpp │ │ │ │ │ │ ├── push_coroutine.ipp │ │ │ │ │ │ └── state.hpp │ │ │ │ │ ├── fixedsize_stack.hpp │ │ │ │ │ ├── pooled_fixedsize_stack.hpp │ │ │ │ │ ├── protected_fixedsize_stack.hpp │ │ │ │ │ └── segmented_stack.hpp │ │ │ │ ├── crc.hpp │ │ │ │ ├── cregex.hpp │ │ │ │ ├── cstdfloat.hpp │ │ │ │ ├── cstdint.hpp │ │ │ │ ├── cstdlib.hpp │ │ │ │ ├── current_function.hpp │ │ │ │ ├── cxx11_char_types.hpp │ │ │ │ ├── date_time/ │ │ │ │ │ ├── adjust_functors.hpp │ │ │ │ │ ├── c_local_time_adjustor.hpp │ │ │ │ │ ├── c_time.hpp │ │ │ │ │ ├── compiler_config.hpp │ │ │ │ │ ├── constrained_value.hpp │ │ │ │ │ ├── date.hpp │ │ │ │ │ ├── date_clock_device.hpp │ │ │ │ │ ├── date_defs.hpp │ │ │ │ │ ├── date_duration.hpp │ │ │ │ │ ├── date_duration_types.hpp │ │ │ │ │ ├── date_facet.hpp │ │ │ │ │ ├── date_format_simple.hpp │ │ │ │ │ ├── date_formatting.hpp │ │ │ │ │ ├── date_formatting_limited.hpp │ │ │ │ │ ├── date_formatting_locales.hpp │ │ │ │ │ ├── date_generator_formatter.hpp │ │ │ │ │ ├── date_generator_parser.hpp │ │ │ │ │ ├── date_generators.hpp │ │ │ │ │ ├── date_iterator.hpp │ │ │ │ │ ├── date_names_put.hpp │ │ │ │ │ ├── date_parsing.hpp │ │ │ │ │ ├── dst_rules.hpp │ │ │ │ │ ├── dst_transition_generators.hpp │ │ │ │ │ ├── filetime_functions.hpp │ │ │ │ │ ├── format_date_parser.hpp │ │ │ │ │ ├── gregorian/ │ │ │ │ │ │ ├── conversion.hpp │ │ │ │ │ │ ├── formatters.hpp │ │ │ │ │ │ ├── formatters_limited.hpp │ │ │ │ │ │ ├── greg_calendar.hpp │ │ │ │ │ │ ├── greg_date.hpp │ │ │ │ │ │ ├── greg_day.hpp │ │ │ │ │ │ ├── greg_day_of_year.hpp │ │ │ │ │ │ ├── greg_duration.hpp │ │ │ │ │ │ ├── greg_duration_types.hpp │ │ │ │ │ │ ├── greg_facet.hpp │ │ │ │ │ │ ├── greg_month.hpp │ │ │ │ │ │ ├── greg_serialize.hpp │ │ │ │ │ │ ├── greg_weekday.hpp │ │ │ │ │ │ ├── greg_year.hpp │ │ │ │ │ │ ├── greg_ymd.hpp │ │ │ │ │ │ ├── gregorian.hpp │ │ │ │ │ │ ├── gregorian_io.hpp │ │ │ │ │ │ ├── gregorian_types.hpp │ │ │ │ │ │ └── parsers.hpp │ │ │ │ │ ├── gregorian_calendar.hpp │ │ │ │ │ ├── gregorian_calendar.ipp │ │ │ │ │ ├── int_adapter.hpp │ │ │ │ │ ├── iso_format.hpp │ │ │ │ │ ├── local_time/ │ │ │ │ │ │ ├── conversion.hpp │ │ │ │ │ │ ├── custom_time_zone.hpp │ │ │ │ │ │ ├── date_duration_operators.hpp │ │ │ │ │ │ ├── dst_transition_day_rules.hpp │ │ │ │ │ │ ├── local_date_time.hpp │ │ │ │ │ │ ├── local_time.hpp │ │ │ │ │ │ ├── local_time_io.hpp │ │ │ │ │ │ ├── local_time_types.hpp │ │ │ │ │ │ ├── posix_time_zone.hpp │ │ │ │ │ │ └── tz_database.hpp │ │ │ │ │ ├── local_time_adjustor.hpp │ │ │ │ │ ├── local_timezone_defs.hpp │ │ │ │ │ ├── locale_config.hpp │ │ │ │ │ ├── microsec_time_clock.hpp │ │ │ │ │ ├── parse_format_base.hpp │ │ │ │ │ ├── period.hpp │ │ │ │ │ ├── period_formatter.hpp │ │ │ │ │ ├── period_parser.hpp │ │ │ │ │ ├── posix_time/ │ │ │ │ │ │ ├── conversion.hpp │ │ │ │ │ │ ├── date_duration_operators.hpp │ │ │ │ │ │ ├── posix_time.hpp │ │ │ │ │ │ ├── posix_time_config.hpp │ │ │ │ │ │ ├── posix_time_duration.hpp │ │ │ │ │ │ ├── posix_time_io.hpp │ │ │ │ │ │ ├── posix_time_legacy_io.hpp │ │ │ │ │ │ ├── posix_time_system.hpp │ │ │ │ │ │ ├── posix_time_types.hpp │ │ │ │ │ │ ├── ptime.hpp │ │ │ │ │ │ ├── time_formatters.hpp │ │ │ │ │ │ ├── time_formatters_limited.hpp │ │ │ │ │ │ ├── time_parsers.hpp │ │ │ │ │ │ ├── time_period.hpp │ │ │ │ │ │ └── time_serialize.hpp │ │ │ │ │ ├── special_defs.hpp │ │ │ │ │ ├── special_values_formatter.hpp │ │ │ │ │ ├── special_values_parser.hpp │ │ │ │ │ ├── string_convert.hpp │ │ │ │ │ ├── string_parse_tree.hpp │ │ │ │ │ ├── strings_from_facet.hpp │ │ │ │ │ ├── time.hpp │ │ │ │ │ ├── time_clock.hpp │ │ │ │ │ ├── time_defs.hpp │ │ │ │ │ ├── time_duration.hpp │ │ │ │ │ ├── time_facet.hpp │ │ │ │ │ ├── time_formatting_streams.hpp │ │ │ │ │ ├── time_iterator.hpp │ │ │ │ │ ├── time_parsing.hpp │ │ │ │ │ ├── time_resolution_traits.hpp │ │ │ │ │ ├── time_system_counted.hpp │ │ │ │ │ ├── time_system_split.hpp │ │ │ │ │ ├── time_zone_base.hpp │ │ │ │ │ ├── time_zone_names.hpp │ │ │ │ │ ├── tz_db_base.hpp │ │ │ │ │ ├── wrapping_int.hpp │ │ │ │ │ └── year_month_day.hpp │ │ │ │ ├── date_time.hpp │ │ │ │ ├── detail/ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── allocator_utilities.hpp │ │ │ │ │ ├── atomic_count.hpp │ │ │ │ │ ├── atomic_redef_macros.hpp │ │ │ │ │ ├── atomic_undef_macros.hpp │ │ │ │ │ ├── basic_pointerbuf.hpp │ │ │ │ │ ├── binary_search.hpp │ │ │ │ │ ├── bitmask.hpp │ │ │ │ │ ├── call_traits.hpp │ │ │ │ │ ├── catch_exceptions.hpp │ │ │ │ │ ├── compressed_pair.hpp │ │ │ │ │ ├── container_fwd.hpp │ │ │ │ │ ├── dynamic_bitset.hpp │ │ │ │ │ ├── endian.hpp │ │ │ │ │ ├── fenv.hpp │ │ │ │ │ ├── has_default_constructor.hpp │ │ │ │ │ ├── identifier.hpp │ │ │ │ │ ├── indirect_traits.hpp │ │ │ │ │ ├── interlocked.hpp │ │ │ │ │ ├── is_incrementable.hpp │ │ │ │ │ ├── is_sorted.hpp │ │ │ │ │ ├── is_xxx.hpp │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ ├── lcast_precision.hpp │ │ │ │ │ ├── lightweight_main.hpp │ │ │ │ │ ├── lightweight_mutex.hpp │ │ │ │ │ ├── lightweight_test.hpp │ │ │ │ │ ├── lightweight_test_report.hpp │ │ │ │ │ ├── lightweight_thread.hpp │ │ │ │ │ ├── named_template_params.hpp │ │ │ │ │ ├── no_exceptions_support.hpp │ │ │ │ │ ├── numeric_traits.hpp │ │ │ │ │ ├── ob_compressed_pair.hpp │ │ │ │ │ ├── quick_allocator.hpp │ │ │ │ │ ├── reference_content.hpp │ │ │ │ │ ├── scoped_enum_emulation.hpp │ │ │ │ │ ├── select_type.hpp │ │ │ │ │ ├── sp_typeinfo.hpp │ │ │ │ │ ├── templated_streams.hpp │ │ │ │ │ ├── utf8_codecvt_facet.hpp │ │ │ │ │ ├── utf8_codecvt_facet.ipp │ │ │ │ │ ├── winapi/ │ │ │ │ │ │ ├── GetCurrentProcess.hpp │ │ │ │ │ │ ├── GetCurrentThread.hpp │ │ │ │ │ │ ├── GetLastError.hpp │ │ │ │ │ │ ├── GetProcessTimes.hpp │ │ │ │ │ │ ├── GetThreadTimes.hpp │ │ │ │ │ │ ├── LocalFree.hpp │ │ │ │ │ │ ├── access_rights.hpp │ │ │ │ │ │ ├── apc.hpp │ │ │ │ │ │ ├── basic_types.hpp │ │ │ │ │ │ ├── character_code_conversion.hpp │ │ │ │ │ │ ├── condition_variable.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── critical_section.hpp │ │ │ │ │ │ ├── crypt.hpp │ │ │ │ │ │ ├── dbghelp.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── cast_ptr.hpp │ │ │ │ │ │ ├── directory_management.hpp │ │ │ │ │ │ ├── dll.hpp │ │ │ │ │ │ ├── environment.hpp │ │ │ │ │ │ ├── error_codes.hpp │ │ │ │ │ │ ├── error_handling.hpp │ │ │ │ │ │ ├── event.hpp │ │ │ │ │ │ ├── file_management.hpp │ │ │ │ │ │ ├── file_mapping.hpp │ │ │ │ │ │ ├── get_current_process.hpp │ │ │ │ │ │ ├── get_current_process_id.hpp │ │ │ │ │ │ ├── get_current_thread.hpp │ │ │ │ │ │ ├── get_current_thread_id.hpp │ │ │ │ │ │ ├── get_last_error.hpp │ │ │ │ │ │ ├── get_process_times.hpp │ │ │ │ │ │ ├── get_system_directory.hpp │ │ │ │ │ │ ├── get_thread_times.hpp │ │ │ │ │ │ ├── handle_info.hpp │ │ │ │ │ │ ├── handles.hpp │ │ │ │ │ │ ├── heap_memory.hpp │ │ │ │ │ │ ├── init_once.hpp │ │ │ │ │ │ ├── jobs.hpp │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ ├── local_memory.hpp │ │ │ │ │ │ ├── memory.hpp │ │ │ │ │ │ ├── mutex.hpp │ │ │ │ │ │ ├── overlapped.hpp │ │ │ │ │ │ ├── page_protection_flags.hpp │ │ │ │ │ │ ├── pipes.hpp │ │ │ │ │ │ ├── priority_class.hpp │ │ │ │ │ │ ├── process.hpp │ │ │ │ │ │ ├── security.hpp │ │ │ │ │ │ ├── semaphore.hpp │ │ │ │ │ │ ├── shell.hpp │ │ │ │ │ │ ├── show_window.hpp │ │ │ │ │ │ ├── srw_lock.hpp │ │ │ │ │ │ ├── synchronization.hpp │ │ │ │ │ │ ├── system.hpp │ │ │ │ │ │ ├── thread.hpp │ │ │ │ │ │ ├── thread_pool.hpp │ │ │ │ │ │ ├── time.hpp │ │ │ │ │ │ ├── timers.hpp │ │ │ │ │ │ ├── tls.hpp │ │ │ │ │ │ ├── wait.hpp │ │ │ │ │ │ └── waitable_timer.hpp │ │ │ │ │ └── workaround.hpp │ │ │ │ ├── dll/ │ │ │ │ │ ├── alias.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── aggressive_ptr_cast.hpp │ │ │ │ │ │ ├── ctor_dtor.hpp │ │ │ │ │ │ ├── demangling/ │ │ │ │ │ │ │ ├── demangle_symbol.hpp │ │ │ │ │ │ │ ├── itanium.hpp │ │ │ │ │ │ │ ├── mangled_storage_base.hpp │ │ │ │ │ │ │ └── msvc.hpp │ │ │ │ │ │ ├── elf_info.hpp │ │ │ │ │ │ ├── get_mem_fn_type.hpp │ │ │ │ │ │ ├── import_mangled_helpers.hpp │ │ │ │ │ │ ├── macho_info.hpp │ │ │ │ │ │ ├── pe_info.hpp │ │ │ │ │ │ ├── posix/ │ │ │ │ │ │ │ ├── path_from_handle.hpp │ │ │ │ │ │ │ ├── program_location_impl.hpp │ │ │ │ │ │ │ └── shared_library_impl.hpp │ │ │ │ │ │ ├── system_error.hpp │ │ │ │ │ │ ├── type_info.hpp │ │ │ │ │ │ ├── windows/ │ │ │ │ │ │ │ ├── path_from_handle.hpp │ │ │ │ │ │ │ └── shared_library_impl.hpp │ │ │ │ │ │ └── x_info_interface.hpp │ │ │ │ │ ├── import.hpp │ │ │ │ │ ├── import_class.hpp │ │ │ │ │ ├── import_mangled.hpp │ │ │ │ │ ├── library_info.hpp │ │ │ │ │ ├── runtime_symbol_info.hpp │ │ │ │ │ ├── shared_library.hpp │ │ │ │ │ ├── shared_library_load_mode.hpp │ │ │ │ │ └── smart_library.hpp │ │ │ │ ├── dll.hpp │ │ │ │ ├── dynamic_bitset/ │ │ │ │ │ ├── config.hpp │ │ │ │ │ └── dynamic_bitset.hpp │ │ │ │ ├── dynamic_bitset.hpp │ │ │ │ ├── dynamic_bitset_fwd.hpp │ │ │ │ ├── enable_shared_from_this.hpp │ │ │ │ ├── endian/ │ │ │ │ │ ├── arithmetic.hpp │ │ │ │ │ ├── buffers.hpp │ │ │ │ │ ├── conversion.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── cover_operators.hpp │ │ │ │ │ │ ├── disable_warnings.hpp │ │ │ │ │ │ ├── disable_warnings_pop.hpp │ │ │ │ │ │ ├── intrinsic.hpp │ │ │ │ │ │ └── lightweight_test.hpp │ │ │ │ │ ├── endian.hpp │ │ │ │ │ └── std_pair.hpp │ │ │ │ ├── exception/ │ │ │ │ │ ├── N3757.hpp │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── current_exception_cast.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── clone_current_exception.hpp │ │ │ │ │ │ ├── error_info_impl.hpp │ │ │ │ │ │ ├── exception_ptr.hpp │ │ │ │ │ │ ├── is_output_streamable.hpp │ │ │ │ │ │ ├── object_hex_dump.hpp │ │ │ │ │ │ ├── shared_ptr.hpp │ │ │ │ │ │ └── type_info.hpp │ │ │ │ │ ├── diagnostic_information.hpp │ │ │ │ │ ├── enable_current_exception.hpp │ │ │ │ │ ├── enable_error_info.hpp │ │ │ │ │ ├── errinfo_api_function.hpp │ │ │ │ │ ├── errinfo_at_line.hpp │ │ │ │ │ ├── errinfo_errno.hpp │ │ │ │ │ ├── errinfo_file_handle.hpp │ │ │ │ │ ├── errinfo_file_name.hpp │ │ │ │ │ ├── errinfo_file_open_mode.hpp │ │ │ │ │ ├── errinfo_nested_exception.hpp │ │ │ │ │ ├── errinfo_type_info_name.hpp │ │ │ │ │ ├── error_info.hpp │ │ │ │ │ ├── exception.hpp │ │ │ │ │ ├── get_error_info.hpp │ │ │ │ │ ├── info.hpp │ │ │ │ │ ├── info_tuple.hpp │ │ │ │ │ ├── to_string.hpp │ │ │ │ │ └── to_string_stub.hpp │ │ │ │ ├── exception_ptr.hpp │ │ │ │ ├── fiber/ │ │ │ │ │ ├── algo/ │ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── chase_lev_queue.hpp │ │ │ │ │ │ ├── round_robin.hpp │ │ │ │ │ │ ├── shared_work.hpp │ │ │ │ │ │ └── work_stealing.hpp │ │ │ │ │ ├── all.hpp │ │ │ │ │ ├── barrier.hpp │ │ │ │ │ ├── bounded_channel.hpp │ │ │ │ │ ├── buffered_channel.hpp │ │ │ │ │ ├── channel_op_status.hpp │ │ │ │ │ ├── condition_variable.hpp │ │ │ │ │ ├── context.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── context_mpsc_queue.hpp │ │ │ │ │ │ ├── context_spmc_queue.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── cpu_relax.hpp │ │ │ │ │ │ ├── data.hpp │ │ │ │ │ │ ├── decay_copy.hpp │ │ │ │ │ │ ├── disable_overload.hpp │ │ │ │ │ │ ├── fss.hpp │ │ │ │ │ │ ├── futex.hpp │ │ │ │ │ │ ├── spinlock.hpp │ │ │ │ │ │ ├── spinlock_ttas.hpp │ │ │ │ │ │ ├── spinlock_ttas_adaptive.hpp │ │ │ │ │ │ ├── spinlock_ttas_adaptive_futex.hpp │ │ │ │ │ │ ├── spinlock_ttas_futex.hpp │ │ │ │ │ │ └── wrap.hpp │ │ │ │ │ ├── exceptions.hpp │ │ │ │ │ ├── fiber.hpp │ │ │ │ │ ├── fixedsize_stack.hpp │ │ │ │ │ ├── fss.hpp │ │ │ │ │ ├── future/ │ │ │ │ │ │ ├── async.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── shared_state.hpp │ │ │ │ │ │ │ ├── shared_state_object.hpp │ │ │ │ │ │ │ ├── task_base.hpp │ │ │ │ │ │ │ └── task_object.hpp │ │ │ │ │ │ ├── future.hpp │ │ │ │ │ │ ├── future_status.hpp │ │ │ │ │ │ ├── packaged_task.hpp │ │ │ │ │ │ └── promise.hpp │ │ │ │ │ ├── future.hpp │ │ │ │ │ ├── mutex.hpp │ │ │ │ │ ├── operations.hpp │ │ │ │ │ ├── policy.hpp │ │ │ │ │ ├── pooled_fixedsize_stack.hpp │ │ │ │ │ ├── properties.hpp │ │ │ │ │ ├── protected_fixedsize_stack.hpp │ │ │ │ │ ├── recursive_mutex.hpp │ │ │ │ │ ├── recursive_timed_mutex.hpp │ │ │ │ │ ├── scheduler.hpp │ │ │ │ │ ├── segmented_stack.hpp │ │ │ │ │ ├── timed_mutex.hpp │ │ │ │ │ ├── type.hpp │ │ │ │ │ ├── unbounded_channel.hpp │ │ │ │ │ └── unbuffered_channel.hpp │ │ │ │ ├── filesystem/ │ │ │ │ │ ├── config.hpp │ │ │ │ │ ├── convenience.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ └── utf8_codecvt_facet.hpp │ │ │ │ │ ├── exception.hpp │ │ │ │ │ ├── fstream.hpp │ │ │ │ │ ├── operations.hpp │ │ │ │ │ ├── path.hpp │ │ │ │ │ ├── path_traits.hpp │ │ │ │ │ └── string_file.hpp │ │ │ │ ├── filesystem.hpp │ │ │ │ ├── flyweight/ │ │ │ │ │ ├── assoc_container_factory.hpp │ │ │ │ │ ├── assoc_container_factory_fwd.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── archive_constructed.hpp │ │ │ │ │ │ ├── default_value_policy.hpp │ │ │ │ │ │ ├── dyn_perfect_fwd.hpp │ │ │ │ │ │ ├── flyweight_core.hpp │ │ │ │ │ │ ├── is_placeholder_expr.hpp │ │ │ │ │ │ ├── nested_xxx_if_not_ph.hpp │ │ │ │ │ │ ├── not_placeholder_expr.hpp │ │ │ │ │ │ ├── perfect_fwd.hpp │ │ │ │ │ │ ├── pp_perfect_fwd.hpp │ │ │ │ │ │ ├── recursive_lw_mutex.hpp │ │ │ │ │ │ ├── serialization_helper.hpp │ │ │ │ │ │ └── value_tag.hpp │ │ │ │ │ ├── factory_tag.hpp │ │ │ │ │ ├── flyweight.hpp │ │ │ │ │ ├── flyweight_fwd.hpp │ │ │ │ │ ├── hashed_factory.hpp │ │ │ │ │ ├── hashed_factory_fwd.hpp │ │ │ │ │ ├── holder_tag.hpp │ │ │ │ │ ├── intermodule_holder.hpp │ │ │ │ │ ├── intermodule_holder_fwd.hpp │ │ │ │ │ ├── key_value.hpp │ │ │ │ │ ├── key_value_fwd.hpp │ │ │ │ │ ├── locking_tag.hpp │ │ │ │ │ ├── no_locking.hpp │ │ │ │ │ ├── no_locking_fwd.hpp │ │ │ │ │ ├── no_tracking.hpp │ │ │ │ │ ├── no_tracking_fwd.hpp │ │ │ │ │ ├── refcounted.hpp │ │ │ │ │ ├── refcounted_fwd.hpp │ │ │ │ │ ├── serialize.hpp │ │ │ │ │ ├── set_factory.hpp │ │ │ │ │ ├── set_factory_fwd.hpp │ │ │ │ │ ├── simple_locking.hpp │ │ │ │ │ ├── simple_locking_fwd.hpp │ │ │ │ │ ├── static_holder.hpp │ │ │ │ │ ├── static_holder_fwd.hpp │ │ │ │ │ ├── tag.hpp │ │ │ │ │ └── tracking_tag.hpp │ │ │ │ ├── flyweight.hpp │ │ │ │ ├── foreach.hpp │ │ │ │ ├── foreach_fwd.hpp │ │ │ │ ├── format/ │ │ │ │ │ ├── alt_sstream.hpp │ │ │ │ │ ├── alt_sstream_impl.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── compat_workarounds.hpp │ │ │ │ │ │ ├── config_macros.hpp │ │ │ │ │ │ ├── msvc_disambiguater.hpp │ │ │ │ │ │ ├── unset_macros.hpp │ │ │ │ │ │ ├── workarounds_gcc-2_95.hpp │ │ │ │ │ │ └── workarounds_stlport.hpp │ │ │ │ │ ├── exceptions.hpp │ │ │ │ │ ├── feed_args.hpp │ │ │ │ │ ├── format_class.hpp │ │ │ │ │ ├── format_fwd.hpp │ │ │ │ │ ├── format_implementation.hpp │ │ │ │ │ ├── free_funcs.hpp │ │ │ │ │ ├── group.hpp │ │ │ │ │ ├── internals.hpp │ │ │ │ │ ├── internals_fwd.hpp │ │ │ │ │ └── parsing.hpp │ │ │ │ ├── format.hpp │ │ │ │ ├── function/ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── function_iterate.hpp │ │ │ │ │ │ ├── gen_maybe_include.pl │ │ │ │ │ │ ├── maybe_include.hpp │ │ │ │ │ │ └── prologue.hpp │ │ │ │ │ ├── function0.hpp │ │ │ │ │ ├── function1.hpp │ │ │ │ │ ├── function10.hpp │ │ │ │ │ ├── function2.hpp │ │ │ │ │ ├── function3.hpp │ │ │ │ │ ├── function4.hpp │ │ │ │ │ ├── function5.hpp │ │ │ │ │ ├── function6.hpp │ │ │ │ │ ├── function7.hpp │ │ │ │ │ ├── function8.hpp │ │ │ │ │ ├── function9.hpp │ │ │ │ │ ├── function_base.hpp │ │ │ │ │ ├── function_fwd.hpp │ │ │ │ │ ├── function_template.hpp │ │ │ │ │ ├── function_typeof.hpp │ │ │ │ │ └── gen_function_N.pl │ │ │ │ ├── function.hpp │ │ │ │ ├── function_equal.hpp │ │ │ │ ├── function_output_iterator.hpp │ │ │ │ ├── function_types/ │ │ │ │ │ ├── components.hpp │ │ │ │ │ ├── config/ │ │ │ │ │ │ ├── cc_names.hpp │ │ │ │ │ │ ├── compiler.hpp │ │ │ │ │ │ └── config.hpp │ │ │ │ │ ├── detail/ │ │ │ │ │ │ ├── class_transform.hpp │ │ │ │ │ │ ├── classifier.hpp │ │ │ │ │ │ ├── classifier_impl/ │ │ │ │ │ │ │ ├── arity10_0.hpp │ │ │ │ │ │ │ ├── arity10_1.hpp │ │ │ │ │ │ │ ├── arity20_0.hpp │ │ │ │ │ │ │ ├── arity20_1.hpp │ │ │ │ │ │ │ ├── arity30_0.hpp │ │ │ │ │ │ │ ├── arity30_1.hpp │ │ │ │ │ │ │ ├── arity40_0.hpp │ │ │ │ │ │ │ ├── arity40_1.hpp │ │ │ │ │ │ │ ├── arity50_0.hpp │ │ │ │ │ │ │ ├── arity50_1.hpp │ │ │ │ │ │ │ └── master.hpp │ │ │ │ │ │ ├── components_as_mpl_sequence.hpp │ │ │ │ │ │ ├── components_impl/ │ │ │ │ │ │ │ ├── arity10_0.hpp │ │ │ │ │ │ │ ├── arity10_1.hpp │ │ │ │ │ │ │ ├── arity20_0.hpp │ │ │ │ │ │ │ ├── arity20_1.hpp │ │ │ │ │ │ │ ├── arity30_0.hpp │ │ │ │ │ │ │ ├── arity30_1.hpp │ │ │ │ │ │ │ ├── arity40_0.hpp │ │ │ │ │ │ │ ├── arity40_1.hpp │ │ │ │ │ │ │ ├── arity50_0.hpp │ │ │ │ │ │ │ ├── arity50_1.hpp │ │ │ │ │ │ │ └── master.hpp │ │ │ │ │ │ ├── cv_traits.hpp │ │ │ │ │ │ ├── encoding/ │ │ │ │ │ │ │ ├── aliases_def.hpp │ │ │ │ │ │ │ ├── aliases_undef.hpp │ │ │ │ │ │ │ ├── def.hpp │ │ │ │ │ │ │ └── undef.hpp │ │ │ │ │ │ ├── pp_arity_loop.hpp │ │ │ │ │ │ ├── pp_cc_loop/ │ │ │ │ │ │ │ ├── master.hpp │ │ │ │ │ │ │ └── preprocessed.hpp │ │ │ │ │ │ ├── pp_loop.hpp │ │ │ │ │ │ ├── pp_retag_default_cc/ │ │ │ │ │ │ │ ├── master.hpp │ │ │ │ │ │ │ └── preprocessed.hpp │ │ │ │ │ │ ├── pp_tags/ │ │ │ │ │ │ │ ├── cc_tag.hpp │ │ │ │ │ │ │ ├── master.hpp │ │ │ │ │ │ │ └── preprocessed.hpp │ │ │ │ │ │ ├── pp_variate_loop/ │ │ │ │ │ │ │ ├── master.hpp │ │ │ │ │ │ │ └── preprocessed.hpp │ │ │ │ │ │ ├── retag_default_cc.hpp │ │ │ │ │ │ ├── synthesize.hpp │ │ │ │ │ │ ├── synthesize_impl/ │ │ │ │ │ │ │ ├── arity10_0.hpp │ │ │ │ │ │ │ ├── arity10_1.hpp │ │ │ │ │ │ │ ├── arity20_0.hpp │ │ │ │ │ │ │ ├── arity20_1.hpp │ │ │ │ │ │ │ ├── arity30_0.hpp │ │ │ │ │ │ │ ├── arity30_1.hpp │ │ │ │ │ │ │ ├── arity40_0.hpp │ │ │ │ │ │ │ ├── arity40_1.hpp │ │ │ │ │ │ │ ├── arity50_0.hpp │ │ │ │ │ │ │ ├── arity50_1.hpp │ │ │ │ │ │ │ └── master.hpp │ │ │ │ │ │ └── to_sequence.hpp │ │ │ │ │ ├── function_arity.hpp │ │ │ │ │ ├── function_pointer.hpp │ │ │ │ │ ├── function_reference.hpp │ │ │ │ │ ├── function_type.hpp │ │ │ │ │ ├── is_callable_builtin.hpp │ │ │ │ │ ├── is_function.hpp │ │ │ │ │ ├── is_function_pointer.hpp │ │ │ │ │ ├── is_function_reference.hpp │ │ │ │ │ ├── is_member_function_pointer.hpp │ │ │ │ │ ├── is_member_object_pointer.hpp │ │ │ │ │ ├── is_member_pointer.hpp │ │ │ │ │ ├── is_nonmember_callable_builtin.hpp │ │ │ │ │ ├── member_function_pointer.hpp │ │ │ │ │ ├── member_object_pointer.hpp │ │ │ │ │ ├── parameter_types.hpp │ │ │ │ │ ├── property_tags.hpp │ │ │ │ │ └── result_type.hpp │ │ │ │ ├── functional/ │ │ │ │ │ ├── factory.hpp │ │ │ │ │ ├── forward_adapter.hpp │ │ │ │ │ ├── hash/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── float_functions.hpp │ │ │ │ │ │ │ ├── hash_float.hpp │ │ │ │ │ │ │ └── limits.hpp │ │ │ │ │ │ ├── extensions.hpp │ │ │ │ │ │ ├── hash.hpp │ │ │ │ │ │ └── hash_fwd.hpp │ │ │ │ │ ├── hash.hpp │ │ │ │ │ ├── hash_fwd.hpp │ │ │ │ │ ├── lightweight_forward_adapter.hpp │ │ │ │ │ ├── overloaded_function/ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ └── detail/ │ │ │ │ │ │ ├── base.hpp │ │ │ │ │ │ └── function_type.hpp │ │ │ │ │ ├── overloaded_function.hpp │ │ │ │ │ └── value_factory.hpp │ │ │ │ ├── functional.hpp │ │ │ │ ├── fusion/ │ │ │ │ │ ├── adapted/ │ │ │ │ │ │ ├── adt/ │ │ │ │ │ │ │ ├── adapt_adt.hpp │ │ │ │ │ │ │ ├── adapt_adt_named.hpp │ │ │ │ │ │ │ ├── adapt_assoc_adt.hpp │ │ │ │ │ │ │ ├── adapt_assoc_adt_named.hpp │ │ │ │ │ │ │ └── detail/ │ │ │ │ │ │ │ ├── adapt_base.hpp │ │ │ │ │ │ │ ├── adapt_base_assoc_attr_filler.hpp │ │ │ │ │ │ │ ├── adapt_base_attr_filler.hpp │ │ │ │ │ │ │ └── extension.hpp │ │ │ │ │ │ ├── adt.hpp │ │ │ │ │ │ ├── array/ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ ├── tag_of.hpp │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ ├── array.hpp │ │ │ │ │ │ ├── boost_array/ │ │ │ │ │ │ │ ├── array_iterator.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ └── tag_of.hpp │ │ │ │ │ │ ├── boost_array.hpp │ │ │ │ │ │ ├── boost_tuple/ │ │ │ │ │ │ │ ├── boost_tuple_iterator.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_cons.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ │ │ └── clear.hpp │ │ │ │ │ │ │ └── tag_of.hpp │ │ │ │ │ │ ├── boost_tuple.hpp │ │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── empty_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── has_key_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ └── mpl_iterator.hpp │ │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ │ ├── std_array/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── array_size.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ ├── std_array_iterator.hpp │ │ │ │ │ │ │ └── tag_of.hpp │ │ │ │ │ │ ├── std_array.hpp │ │ │ │ │ │ ├── std_pair.hpp │ │ │ │ │ │ ├── std_tuple/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_std_tuple.hpp │ │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ │ │ └── clear.hpp │ │ │ │ │ │ │ ├── std_tuple_iterator.hpp │ │ │ │ │ │ │ └── tag_of.hpp │ │ │ │ │ │ ├── std_tuple.hpp │ │ │ │ │ │ ├── struct/ │ │ │ │ │ │ │ ├── adapt_assoc_struct.hpp │ │ │ │ │ │ │ ├── adapt_assoc_struct_named.hpp │ │ │ │ │ │ │ ├── adapt_struct.hpp │ │ │ │ │ │ │ ├── adapt_struct_named.hpp │ │ │ │ │ │ │ ├── define_assoc_struct.hpp │ │ │ │ │ │ │ ├── define_struct.hpp │ │ │ │ │ │ │ ├── define_struct_inline.hpp │ │ │ │ │ │ │ └── detail/ │ │ │ │ │ │ │ ├── adapt_auto.hpp │ │ │ │ │ │ │ ├── adapt_base.hpp │ │ │ │ │ │ │ ├── adapt_base_assoc_attr_filler.hpp │ │ │ │ │ │ │ ├── adapt_base_attr_filler.hpp │ │ │ │ │ │ │ ├── adapt_is_tpl.hpp │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ ├── category_of_impl.hpp │ │ │ │ │ │ │ ├── define_struct.hpp │ │ │ │ │ │ │ ├── define_struct_inline.hpp │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ ├── extension.hpp │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ ├── is_view_impl.hpp │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ ├── namespace.hpp │ │ │ │ │ │ │ ├── preprocessor/ │ │ │ │ │ │ │ │ └── is_seq.hpp │ │ │ │ │ │ │ ├── proxy_type.hpp │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ └── struct.hpp │ │ │ │ │ ├── adapted.hpp │ │ │ │ │ ├── algorithm/ │ │ │ │ │ │ ├── auxiliary/ │ │ │ │ │ │ │ ├── copy.hpp │ │ │ │ │ │ │ └── move.hpp │ │ │ │ │ │ ├── auxiliary.hpp │ │ │ │ │ │ ├── iteration/ │ │ │ │ │ │ │ ├── accumulate.hpp │ │ │ │ │ │ │ ├── accumulate_fwd.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── fold.hpp │ │ │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ ├── fold.hpp │ │ │ │ │ │ │ │ │ ├── iter_fold.hpp │ │ │ │ │ │ │ │ │ ├── reverse_fold.hpp │ │ │ │ │ │ │ │ │ └── reverse_iter_fold.hpp │ │ │ │ │ │ │ │ ├── segmented_fold.hpp │ │ │ │ │ │ │ │ └── segmented_for_each.hpp │ │ │ │ │ │ │ ├── fold.hpp │ │ │ │ │ │ │ ├── fold_fwd.hpp │ │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ │ ├── for_each_fwd.hpp │ │ │ │ │ │ │ ├── iter_fold.hpp │ │ │ │ │ │ │ ├── iter_fold_fwd.hpp │ │ │ │ │ │ │ ├── reverse_fold.hpp │ │ │ │ │ │ │ ├── reverse_fold_fwd.hpp │ │ │ │ │ │ │ ├── reverse_iter_fold.hpp │ │ │ │ │ │ │ └── reverse_iter_fold_fwd.hpp │ │ │ │ │ │ ├── iteration.hpp │ │ │ │ │ │ ├── query/ │ │ │ │ │ │ │ ├── all.hpp │ │ │ │ │ │ │ ├── any.hpp │ │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ │ ├── count_if.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── all.hpp │ │ │ │ │ │ │ │ ├── any.hpp │ │ │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ │ │ ├── count_if.hpp │ │ │ │ │ │ │ │ ├── find_if.hpp │ │ │ │ │ │ │ │ ├── segmented_find.hpp │ │ │ │ │ │ │ │ └── segmented_find_if.hpp │ │ │ │ │ │ │ ├── find.hpp │ │ │ │ │ │ │ ├── find_fwd.hpp │ │ │ │ │ │ │ ├── find_if.hpp │ │ │ │ │ │ │ ├── find_if_fwd.hpp │ │ │ │ │ │ │ └── none.hpp │ │ │ │ │ │ ├── query.hpp │ │ │ │ │ │ ├── transformation/ │ │ │ │ │ │ │ ├── clear.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ ├── zip.hpp │ │ │ │ │ │ │ │ │ ├── zip10.hpp │ │ │ │ │ │ │ │ │ ├── zip20.hpp │ │ │ │ │ │ │ │ │ ├── zip30.hpp │ │ │ │ │ │ │ │ │ ├── zip40.hpp │ │ │ │ │ │ │ │ │ └── zip50.hpp │ │ │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ │ │ └── replace_if.hpp │ │ │ │ │ │ │ ├── erase.hpp │ │ │ │ │ │ │ ├── erase_key.hpp │ │ │ │ │ │ │ ├── filter.hpp │ │ │ │ │ │ │ ├── filter_if.hpp │ │ │ │ │ │ │ ├── flatten.hpp │ │ │ │ │ │ │ ├── insert.hpp │ │ │ │ │ │ │ ├── insert_range.hpp │ │ │ │ │ │ │ ├── join.hpp │ │ │ │ │ │ │ ├── pop_back.hpp │ │ │ │ │ │ │ ├── pop_front.hpp │ │ │ │ │ │ │ ├── push_back.hpp │ │ │ │ │ │ │ ├── push_front.hpp │ │ │ │ │ │ │ ├── remove.hpp │ │ │ │ │ │ │ ├── remove_if.hpp │ │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ │ ├── replace_if.hpp │ │ │ │ │ │ │ ├── reverse.hpp │ │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ │ └── zip.hpp │ │ │ │ │ │ └── transformation.hpp │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ ├── container/ │ │ │ │ │ │ ├── deque/ │ │ │ │ │ │ │ ├── back_extended_deque.hpp │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ │ ├── deque_fwd.hpp │ │ │ │ │ │ │ ├── deque_iterator.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_deque.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── as_deque.hpp │ │ │ │ │ │ │ │ │ ├── build_deque.hpp │ │ │ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ │ │ │ ├── deque_forward_ctor.hpp │ │ │ │ │ │ │ │ │ ├── deque_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values_call.hpp │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ └── preprocessed/ │ │ │ │ │ │ │ │ │ ├── as_deque.hpp │ │ │ │ │ │ │ │ │ ├── as_deque10.hpp │ │ │ │ │ │ │ │ │ ├── as_deque20.hpp │ │ │ │ │ │ │ │ │ ├── as_deque30.hpp │ │ │ │ │ │ │ │ │ ├── as_deque40.hpp │ │ │ │ │ │ │ │ │ ├── as_deque50.hpp │ │ │ │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ │ │ │ ├── deque10.hpp │ │ │ │ │ │ │ │ │ ├── deque10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque20.hpp │ │ │ │ │ │ │ │ │ ├── deque20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque30.hpp │ │ │ │ │ │ │ │ │ ├── deque30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque40.hpp │ │ │ │ │ │ │ │ │ ├── deque40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque50.hpp │ │ │ │ │ │ │ │ │ ├── deque50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque_fwd.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size10.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size20.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size30.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size40.hpp │ │ │ │ │ │ │ │ │ ├── deque_initial_size50.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values10.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values20.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values30.hpp │ │ │ │ │ │ │ │ │ ├── deque_keyed_values40.hpp │ │ │ │ │ │ │ │ │ └── deque_keyed_values50.hpp │ │ │ │ │ │ │ │ ├── deque_keyed_values.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_sequence_impl.hpp │ │ │ │ │ │ │ │ ├── keyed_element.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ └── front_extended_deque.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── generation/ │ │ │ │ │ │ │ ├── cons_tie.hpp │ │ │ │ │ │ │ ├── deque_tie.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── pp_deque_tie.hpp │ │ │ │ │ │ │ │ ├── pp_list_tie.hpp │ │ │ │ │ │ │ │ ├── pp_make_deque.hpp │ │ │ │ │ │ │ │ ├── pp_make_list.hpp │ │ │ │ │ │ │ │ ├── pp_make_map.hpp │ │ │ │ │ │ │ │ ├── pp_make_set.hpp │ │ │ │ │ │ │ │ ├── pp_make_vector.hpp │ │ │ │ │ │ │ │ ├── pp_map_tie.hpp │ │ │ │ │ │ │ │ ├── pp_vector_tie.hpp │ │ │ │ │ │ │ │ └── preprocessed/ │ │ │ │ │ │ │ │ ├── deque_tie.hpp │ │ │ │ │ │ │ │ ├── deque_tie10.hpp │ │ │ │ │ │ │ │ ├── deque_tie20.hpp │ │ │ │ │ │ │ │ ├── deque_tie30.hpp │ │ │ │ │ │ │ │ ├── deque_tie40.hpp │ │ │ │ │ │ │ │ ├── deque_tie50.hpp │ │ │ │ │ │ │ │ ├── list_tie.hpp │ │ │ │ │ │ │ │ ├── list_tie10.hpp │ │ │ │ │ │ │ │ ├── list_tie20.hpp │ │ │ │ │ │ │ │ ├── list_tie30.hpp │ │ │ │ │ │ │ │ ├── list_tie40.hpp │ │ │ │ │ │ │ │ ├── list_tie50.hpp │ │ │ │ │ │ │ │ ├── make_deque.hpp │ │ │ │ │ │ │ │ ├── make_deque10.hpp │ │ │ │ │ │ │ │ ├── make_deque20.hpp │ │ │ │ │ │ │ │ ├── make_deque30.hpp │ │ │ │ │ │ │ │ ├── make_deque40.hpp │ │ │ │ │ │ │ │ ├── make_deque50.hpp │ │ │ │ │ │ │ │ ├── make_list.hpp │ │ │ │ │ │ │ │ ├── make_list10.hpp │ │ │ │ │ │ │ │ ├── make_list20.hpp │ │ │ │ │ │ │ │ ├── make_list30.hpp │ │ │ │ │ │ │ │ ├── make_list40.hpp │ │ │ │ │ │ │ │ ├── make_list50.hpp │ │ │ │ │ │ │ │ ├── make_map.hpp │ │ │ │ │ │ │ │ ├── make_map10.hpp │ │ │ │ │ │ │ │ ├── make_map20.hpp │ │ │ │ │ │ │ │ ├── make_map30.hpp │ │ │ │ │ │ │ │ ├── make_map40.hpp │ │ │ │ │ │ │ │ ├── make_map50.hpp │ │ │ │ │ │ │ │ ├── make_set.hpp │ │ │ │ │ │ │ │ ├── make_set10.hpp │ │ │ │ │ │ │ │ ├── make_set20.hpp │ │ │ │ │ │ │ │ ├── make_set30.hpp │ │ │ │ │ │ │ │ ├── make_set40.hpp │ │ │ │ │ │ │ │ ├── make_set50.hpp │ │ │ │ │ │ │ │ ├── make_vector.hpp │ │ │ │ │ │ │ │ ├── make_vector10.hpp │ │ │ │ │ │ │ │ ├── make_vector20.hpp │ │ │ │ │ │ │ │ ├── make_vector30.hpp │ │ │ │ │ │ │ │ ├── make_vector40.hpp │ │ │ │ │ │ │ │ ├── make_vector50.hpp │ │ │ │ │ │ │ │ ├── map_tie.hpp │ │ │ │ │ │ │ │ ├── map_tie10.hpp │ │ │ │ │ │ │ │ ├── map_tie20.hpp │ │ │ │ │ │ │ │ ├── map_tie30.hpp │ │ │ │ │ │ │ │ ├── map_tie40.hpp │ │ │ │ │ │ │ │ ├── map_tie50.hpp │ │ │ │ │ │ │ │ ├── vector_tie.hpp │ │ │ │ │ │ │ │ ├── vector_tie10.hpp │ │ │ │ │ │ │ │ ├── vector_tie20.hpp │ │ │ │ │ │ │ │ ├── vector_tie30.hpp │ │ │ │ │ │ │ │ ├── vector_tie40.hpp │ │ │ │ │ │ │ │ └── vector_tie50.hpp │ │ │ │ │ │ │ ├── ignore.hpp │ │ │ │ │ │ │ ├── list_tie.hpp │ │ │ │ │ │ │ ├── make_cons.hpp │ │ │ │ │ │ │ ├── make_deque.hpp │ │ │ │ │ │ │ ├── make_list.hpp │ │ │ │ │ │ │ ├── make_map.hpp │ │ │ │ │ │ │ ├── make_set.hpp │ │ │ │ │ │ │ ├── make_vector.hpp │ │ │ │ │ │ │ ├── map_tie.hpp │ │ │ │ │ │ │ ├── pair_tie.hpp │ │ │ │ │ │ │ └── vector_tie.hpp │ │ │ │ │ │ ├── generation.hpp │ │ │ │ │ │ ├── list/ │ │ │ │ │ │ │ ├── cons.hpp │ │ │ │ │ │ │ ├── cons_fwd.hpp │ │ │ │ │ │ │ ├── cons_iterator.hpp │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_cons.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ │ │ │ ├── list_forward_ctor.hpp │ │ │ │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons_call.hpp │ │ │ │ │ │ │ │ │ └── preprocessed/ │ │ │ │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ │ │ │ ├── list10.hpp │ │ │ │ │ │ │ │ │ ├── list10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list20.hpp │ │ │ │ │ │ │ │ │ ├── list20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list30.hpp │ │ │ │ │ │ │ │ │ ├── list30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list40.hpp │ │ │ │ │ │ │ │ │ ├── list40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list50.hpp │ │ │ │ │ │ │ │ │ ├── list50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons10.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons20.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons30.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons40.hpp │ │ │ │ │ │ │ │ │ └── list_to_cons50.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── empty_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── list_forward_ctor.hpp │ │ │ │ │ │ │ │ ├── list_to_cons.hpp │ │ │ │ │ │ │ │ ├── list_to_cons_call.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ │ │ │ ├── list10.hpp │ │ │ │ │ │ │ │ │ ├── list10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list20.hpp │ │ │ │ │ │ │ │ │ ├── list20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list30.hpp │ │ │ │ │ │ │ │ │ ├── list30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list40.hpp │ │ │ │ │ │ │ │ │ ├── list40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list50.hpp │ │ │ │ │ │ │ │ │ ├── list50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons10.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons20.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons30.hpp │ │ │ │ │ │ │ │ │ ├── list_to_cons40.hpp │ │ │ │ │ │ │ │ │ └── list_to_cons50.hpp │ │ │ │ │ │ │ │ ├── reverse_cons.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ │ └── nil.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── map/ │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── at_key_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── build_map.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── as_map.hpp │ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ │ │ │ ├── map_forward_ctor.hpp │ │ │ │ │ │ │ │ │ ├── map_fwd.hpp │ │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ │ ├── as_map.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map10.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map20.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map30.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map40.hpp │ │ │ │ │ │ │ │ │ │ ├── as_map50.hpp │ │ │ │ │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ │ │ │ │ ├── map10.hpp │ │ │ │ │ │ │ │ │ │ ├── map10_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── map20.hpp │ │ │ │ │ │ │ │ │ │ ├── map20_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── map30.hpp │ │ │ │ │ │ │ │ │ │ ├── map30_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── map40.hpp │ │ │ │ │ │ │ │ │ │ ├── map40_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── map50.hpp │ │ │ │ │ │ │ │ │ │ ├── map50_fwd.hpp │ │ │ │ │ │ │ │ │ │ └── map_fwd.hpp │ │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── map_impl.hpp │ │ │ │ │ │ │ │ ├── map_index.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_at_key_impl.hpp │ │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ │ ├── map_fwd.hpp │ │ │ │ │ │ │ └── map_iterator.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── set/ │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set10.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set20.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set30.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set40.hpp │ │ │ │ │ │ │ │ │ │ ├── as_set50.hpp │ │ │ │ │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ │ │ │ │ ├── set10.hpp │ │ │ │ │ │ │ │ │ │ ├── set10_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── set20.hpp │ │ │ │ │ │ │ │ │ │ ├── set20_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── set30.hpp │ │ │ │ │ │ │ │ │ │ ├── set30_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── set40.hpp │ │ │ │ │ │ │ │ │ │ ├── set40_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── set50.hpp │ │ │ │ │ │ │ │ │ │ ├── set50_fwd.hpp │ │ │ │ │ │ │ │ │ │ └── set_fwd.hpp │ │ │ │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ │ │ │ ├── set_forward_ctor.hpp │ │ │ │ │ │ │ │ │ └── set_fwd.hpp │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ │ │ │ ├── as_set10.hpp │ │ │ │ │ │ │ │ │ ├── as_set20.hpp │ │ │ │ │ │ │ │ │ ├── as_set30.hpp │ │ │ │ │ │ │ │ │ ├── as_set40.hpp │ │ │ │ │ │ │ │ │ ├── as_set50.hpp │ │ │ │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ │ │ │ ├── set10.hpp │ │ │ │ │ │ │ │ │ ├── set10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── set20.hpp │ │ │ │ │ │ │ │ │ ├── set20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── set30.hpp │ │ │ │ │ │ │ │ │ ├── set30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── set40.hpp │ │ │ │ │ │ │ │ │ ├── set40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── set50.hpp │ │ │ │ │ │ │ │ │ ├── set50_fwd.hpp │ │ │ │ │ │ │ │ │ └── set_fwd.hpp │ │ │ │ │ │ │ │ ├── set_forward_ctor.hpp │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ │ └── set_fwd.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── vector/ │ │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ │ │ ├── convert_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector10.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector20.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector30.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector40.hpp │ │ │ │ │ │ │ │ │ │ ├── as_vector50.hpp │ │ │ │ │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser10.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser20.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser30.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser40.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_chooser50.hpp │ │ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector10.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector10_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector20.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector20_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector30.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector30_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector40.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector40_fwd.hpp │ │ │ │ │ │ │ │ │ │ ├── vvector50.hpp │ │ │ │ │ │ │ │ │ │ └── vvector50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector_forward_ctor.hpp │ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector_n.hpp │ │ │ │ │ │ │ │ │ └── vector_n_chooser.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ │ │ │ ├── as_vector10.hpp │ │ │ │ │ │ │ │ │ ├── as_vector20.hpp │ │ │ │ │ │ │ │ │ ├── as_vector30.hpp │ │ │ │ │ │ │ │ │ ├── as_vector40.hpp │ │ │ │ │ │ │ │ │ ├── as_vector50.hpp │ │ │ │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ │ │ │ ├── vector10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ │ │ │ ├── vector20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ │ │ │ ├── vector30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ │ │ │ ├── vector40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ │ │ │ ├── vector50_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vector_chooser.hpp │ │ │ │ │ │ │ │ │ ├── vector_chooser10.hpp │ │ │ │ │ │ │ │ │ ├── vector_chooser20.hpp │ │ │ │ │ │ │ │ │ ├── vector_chooser30.hpp │ │ │ │ │ │ │ │ │ ├── vector_chooser40.hpp │ │ │ │ │ │ │ │ │ ├── vector_chooser50.hpp │ │ │ │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vvector10.hpp │ │ │ │ │ │ │ │ │ ├── vvector10_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vvector20.hpp │ │ │ │ │ │ │ │ │ ├── vvector20_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vvector30.hpp │ │ │ │ │ │ │ │ │ ├── vvector30_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vvector40.hpp │ │ │ │ │ │ │ │ │ ├── vvector40_fwd.hpp │ │ │ │ │ │ │ │ │ ├── vvector50.hpp │ │ │ │ │ │ │ │ │ └── vvector50_fwd.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ ├── value_of_impl.hpp │ │ │ │ │ │ │ │ ├── vector_forward_ctor.hpp │ │ │ │ │ │ │ │ ├── vector_n.hpp │ │ │ │ │ │ │ │ └── vector_n_chooser.hpp │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ │ ├── vector10_fwd.hpp │ │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ │ ├── vector20_fwd.hpp │ │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ │ ├── vector30_fwd.hpp │ │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ │ ├── vector40_fwd.hpp │ │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ │ ├── vector50_fwd.hpp │ │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ │ └── vector_iterator.hpp │ │ │ │ │ │ └── vector.hpp │ │ │ │ │ ├── container.hpp │ │ │ │ │ ├── functional/ │ │ │ │ │ │ ├── adapter/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ └── access.hpp │ │ │ │ │ │ │ ├── fused.hpp │ │ │ │ │ │ │ ├── fused_function_object.hpp │ │ │ │ │ │ │ ├── fused_procedure.hpp │ │ │ │ │ │ │ ├── limits.hpp │ │ │ │ │ │ │ ├── unfused.hpp │ │ │ │ │ │ │ └── unfused_typed.hpp │ │ │ │ │ │ ├── adapter.hpp │ │ │ │ │ │ ├── generation/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ └── gen_make_adapter.hpp │ │ │ │ │ │ │ ├── make_fused.hpp │ │ │ │ │ │ │ ├── make_fused_function_object.hpp │ │ │ │ │ │ │ ├── make_fused_procedure.hpp │ │ │ │ │ │ │ └── make_unfused.hpp │ │ │ │ │ │ ├── generation.hpp │ │ │ │ │ │ ├── invocation/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ └── that_ptr.hpp │ │ │ │ │ │ │ ├── invoke.hpp │ │ │ │ │ │ │ ├── invoke_function_object.hpp │ │ │ │ │ │ │ ├── invoke_procedure.hpp │ │ │ │ │ │ │ └── limits.hpp │ │ │ │ │ │ └── invocation.hpp │ │ │ │ │ ├── functional.hpp │ │ │ │ │ ├── include/ │ │ │ │ │ │ ├── accumulate.hpp │ │ │ │ │ │ ├── adapt_adt.hpp │ │ │ │ │ │ ├── adapt_adt_named.cpp │ │ │ │ │ │ ├── adapt_adt_named.hpp │ │ │ │ │ │ ├── adapt_assoc_adt.hpp │ │ │ │ │ │ ├── adapt_assoc_adt_named.hpp │ │ │ │ │ │ ├── adapt_assoc_class.hpp │ │ │ │ │ │ ├── adapt_assoc_class_named.hpp │ │ │ │ │ │ ├── adapt_assoc_struct.hpp │ │ │ │ │ │ ├── adapt_assoc_struct_named.hpp │ │ │ │ │ │ ├── adapt_struct.hpp │ │ │ │ │ │ ├── adapt_struct_named.hpp │ │ │ │ │ │ ├── adapted.hpp │ │ │ │ │ │ ├── adapter.hpp │ │ │ │ │ │ ├── advance.hpp │ │ │ │ │ │ ├── algorithm.hpp │ │ │ │ │ │ ├── all.hpp │ │ │ │ │ │ ├── any.hpp │ │ │ │ │ │ ├── array.hpp │ │ │ │ │ │ ├── as_deque.hpp │ │ │ │ │ │ ├── as_list.hpp │ │ │ │ │ │ ├── as_map.hpp │ │ │ │ │ │ ├── as_set.hpp │ │ │ │ │ │ ├── as_vector.hpp │ │ │ │ │ │ ├── at.hpp │ │ │ │ │ │ ├── at_c.hpp │ │ │ │ │ │ ├── at_key.hpp │ │ │ │ │ │ ├── auxiliary.hpp │ │ │ │ │ │ ├── back.hpp │ │ │ │ │ │ ├── begin.hpp │ │ │ │ │ │ ├── boost_array.hpp │ │ │ │ │ │ ├── boost_tuple.hpp │ │ │ │ │ │ ├── category_of.hpp │ │ │ │ │ │ ├── clear.hpp │ │ │ │ │ │ ├── comparison.hpp │ │ │ │ │ │ ├── cons.hpp │ │ │ │ │ │ ├── cons_tie.hpp │ │ │ │ │ │ ├── container.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── copy.hpp │ │ │ │ │ │ ├── count.hpp │ │ │ │ │ │ ├── count_if.hpp │ │ │ │ │ │ ├── deduce.hpp │ │ │ │ │ │ ├── deduce_sequence.hpp │ │ │ │ │ │ ├── define_assoc_struct.hpp │ │ │ │ │ │ ├── define_struct.hpp │ │ │ │ │ │ ├── define_struct_inline.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── deque_fwd.hpp │ │ │ │ │ │ ├── deque_tie.hpp │ │ │ │ │ │ ├── deref.hpp │ │ │ │ │ │ ├── deref_data.hpp │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ ├── empty.hpp │ │ │ │ │ │ ├── end.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── erase.hpp │ │ │ │ │ │ ├── erase_key.hpp │ │ │ │ │ │ ├── filter.hpp │ │ │ │ │ │ ├── filter_if.hpp │ │ │ │ │ │ ├── filter_view.hpp │ │ │ │ │ │ ├── find.hpp │ │ │ │ │ │ ├── find_if.hpp │ │ │ │ │ │ ├── flatten.hpp │ │ │ │ │ │ ├── flatten_view.hpp │ │ │ │ │ │ ├── fold.hpp │ │ │ │ │ │ ├── for_each.hpp │ │ │ │ │ │ ├── front.hpp │ │ │ │ │ │ ├── functional.hpp │ │ │ │ │ │ ├── fused.hpp │ │ │ │ │ │ ├── fused_function_object.hpp │ │ │ │ │ │ ├── fused_procedure.hpp │ │ │ │ │ │ ├── generation.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── has_key.hpp │ │ │ │ │ │ ├── hash.hpp │ │ │ │ │ │ ├── ignore.hpp │ │ │ │ │ │ ├── in.hpp │ │ │ │ │ │ ├── insert.hpp │ │ │ │ │ │ ├── insert_range.hpp │ │ │ │ │ │ ├── intrinsic.hpp │ │ │ │ │ │ ├── invocation.hpp │ │ │ │ │ │ ├── invoke.hpp │ │ │ │ │ │ ├── invoke_function_object.hpp │ │ │ │ │ │ ├── invoke_procedure.hpp │ │ │ │ │ │ ├── io.hpp │ │ │ │ │ │ ├── is_iterator.hpp │ │ │ │ │ │ ├── is_segmented.hpp │ │ │ │ │ │ ├── is_sequence.hpp │ │ │ │ │ │ ├── is_view.hpp │ │ │ │ │ │ ├── iter_fold.hpp │ │ │ │ │ │ ├── iteration.hpp │ │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ │ ├── iterator_adapter.hpp │ │ │ │ │ │ ├── iterator_base.hpp │ │ │ │ │ │ ├── iterator_facade.hpp │ │ │ │ │ │ ├── iterator_range.hpp │ │ │ │ │ │ ├── join.hpp │ │ │ │ │ │ ├── joint_view.hpp │ │ │ │ │ │ ├── key_of.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_fwd.hpp │ │ │ │ │ │ ├── list_tie.hpp │ │ │ │ │ │ ├── make_cons.hpp │ │ │ │ │ │ ├── make_deque.hpp │ │ │ │ │ │ ├── make_fused.hpp │ │ │ │ │ │ ├── make_fused_function_object.hpp │ │ │ │ │ │ ├── make_fused_procedure.hpp │ │ │ │ │ │ ├── make_list.hpp │ │ │ │ │ │ ├── make_map.hpp │ │ │ │ │ │ ├── make_set.hpp │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ ├── make_unfused.hpp │ │ │ │ │ │ ├── make_vector.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── map_fwd.hpp │ │ │ │ │ │ ├── map_tie.hpp │ │ │ │ │ │ ├── move.hpp │ │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ │ ├── next.hpp │ │ │ │ │ │ ├── nil.hpp │ │ │ │ │ │ ├── none.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── nview.hpp │ │ │ │ │ │ ├── out.hpp │ │ │ │ │ │ ├── pair.hpp │ │ │ │ │ │ ├── pair_tie.hpp │ │ │ │ │ │ ├── pop_back.hpp │ │ │ │ │ │ ├── pop_front.hpp │ │ │ │ │ │ ├── prior.hpp │ │ │ │ │ │ ├── proxy_type.hpp │ │ │ │ │ │ ├── push_back.hpp │ │ │ │ │ │ ├── push_front.hpp │ │ │ │ │ │ ├── query.hpp │ │ │ │ │ │ ├── remove.hpp │ │ │ │ │ │ ├── remove_if.hpp │ │ │ │ │ │ ├── repetitive_view.hpp │ │ │ │ │ │ ├── replace.hpp │ │ │ │ │ │ ├── replace_if.hpp │ │ │ │ │ │ ├── reverse.hpp │ │ │ │ │ │ ├── reverse_fold.hpp │ │ │ │ │ │ ├── reverse_iter_fold.hpp │ │ │ │ │ │ ├── reverse_view.hpp │ │ │ │ │ │ ├── segmented_fold_until.hpp │ │ │ │ │ │ ├── segmented_iterator.hpp │ │ │ │ │ │ ├── segments.hpp │ │ │ │ │ │ ├── sequence.hpp │ │ │ │ │ │ ├── sequence_base.hpp │ │ │ │ │ │ ├── sequence_facade.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_fwd.hpp │ │ │ │ │ │ ├── single_view.hpp │ │ │ │ │ │ ├── size.hpp │ │ │ │ │ │ ├── std_pair.hpp │ │ │ │ │ │ ├── std_tuple.hpp │ │ │ │ │ │ ├── struct.hpp │ │ │ │ │ │ ├── support.hpp │ │ │ │ │ │ ├── swap.hpp │ │ │ │ │ │ ├── tag_of.hpp │ │ │ │ │ │ ├── tag_of_fwd.hpp │ │ │ │ │ │ ├── transform.hpp │ │ │ │ │ │ ├── transform_view.hpp │ │ │ │ │ │ ├── transformation.hpp │ │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ │ ├── tuple_fwd.hpp │ │ │ │ │ │ ├── tuple_tie.hpp │ │ │ │ │ │ ├── unfused.hpp │ │ │ │ │ │ ├── unfused_typed.hpp │ │ │ │ │ │ ├── unused.hpp │ │ │ │ │ │ ├── value_at.hpp │ │ │ │ │ │ ├── value_at_key.hpp │ │ │ │ │ │ ├── value_of.hpp │ │ │ │ │ │ ├── value_of_data.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ ├── vector10.hpp │ │ │ │ │ │ ├── vector20.hpp │ │ │ │ │ │ ├── vector30.hpp │ │ │ │ │ │ ├── vector40.hpp │ │ │ │ │ │ ├── vector50.hpp │ │ │ │ │ │ ├── vector_fwd.hpp │ │ │ │ │ │ ├── vector_tie.hpp │ │ │ │ │ │ ├── view.hpp │ │ │ │ │ │ ├── void.hpp │ │ │ │ │ │ ├── zip.hpp │ │ │ │ │ │ └── zip_view.hpp │ │ │ │ │ ├── iterator/ │ │ │ │ │ │ ├── advance.hpp │ │ │ │ │ │ ├── basic_iterator.hpp │ │ │ │ │ │ ├── deref.hpp │ │ │ │ │ │ ├── deref_data.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── adapt_deref_traits.hpp │ │ │ │ │ │ │ ├── adapt_value_traits.hpp │ │ │ │ │ │ │ ├── advance.hpp │ │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ │ ├── segment_sequence.hpp │ │ │ │ │ │ │ ├── segmented_equal_to.hpp │ │ │ │ │ │ │ ├── segmented_iterator.hpp │ │ │ │ │ │ │ └── segmented_next_impl.hpp │ │ │ │ │ │ ├── distance.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── iterator_adapter.hpp │ │ │ │ │ │ ├── iterator_facade.hpp │ │ │ │ │ │ ├── key_of.hpp │ │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ │ ├── convert_iterator.hpp │ │ │ │ │ │ │ └── fusion_iterator.hpp │ │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ │ ├── next.hpp │ │ │ │ │ │ ├── prior.hpp │ │ │ │ │ │ ├── segmented_iterator.hpp │ │ │ │ │ │ ├── value_of.hpp │ │ │ │ │ │ └── value_of_data.hpp │ │ │ │ │ ├── iterator.hpp │ │ │ │ │ ├── mpl/ │ │ │ │ │ │ ├── at.hpp │ │ │ │ │ │ ├── back.hpp │ │ │ │ │ │ ├── begin.hpp │ │ │ │ │ │ ├── clear.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── clear.hpp │ │ │ │ │ │ ├── empty.hpp │ │ │ │ │ │ ├── end.hpp │ │ │ │ │ │ ├── erase.hpp │ │ │ │ │ │ ├── erase_key.hpp │ │ │ │ │ │ ├── front.hpp │ │ │ │ │ │ ├── has_key.hpp │ │ │ │ │ │ ├── insert.hpp │ │ │ │ │ │ ├── insert_range.hpp │ │ │ │ │ │ ├── pop_back.hpp │ │ │ │ │ │ ├── pop_front.hpp │ │ │ │ │ │ ├── push_back.hpp │ │ │ │ │ │ ├── push_front.hpp │ │ │ │ │ │ └── size.hpp │ │ │ │ │ ├── mpl.hpp │ │ │ │ │ ├── sequence/ │ │ │ │ │ │ ├── comparison/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ │ │ └── not_equal_to.hpp │ │ │ │ │ │ │ ├── enable_comparison.hpp │ │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ │ └── not_equal_to.hpp │ │ │ │ │ │ ├── comparison.hpp │ │ │ │ │ │ ├── convert.hpp │ │ │ │ │ │ ├── hash.hpp │ │ │ │ │ │ ├── intrinsic/ │ │ │ │ │ │ │ ├── at.hpp │ │ │ │ │ │ │ ├── at_c.hpp │ │ │ │ │ │ │ ├── at_key.hpp │ │ │ │ │ │ │ ├── back.hpp │ │ │ │ │ │ │ ├── begin.hpp │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── segmented_begin.hpp │ │ │ │ │ │ │ │ ├── segmented_begin_impl.hpp │ │ │ │ │ │ │ │ ├── segmented_end.hpp │ │ │ │ │ │ │ │ ├── segmented_end_impl.hpp │ │ │ │ │ │ │ │ └── segmented_size.hpp │ │ │ │ │ │ │ ├── empty.hpp │ │ │ │ │ │ │ ├── end.hpp │ │ │ │ │ │ │ ├── front.hpp │ │ │ │ │ │ │ ├── has_key.hpp │ │ │ │ │ │ │ ├── segments.hpp │ │ │ │ │ │ │ ├── size.hpp │ │ │ │ │ │ │ ├── swap.hpp │ │ │ │ │ │ │ ├── value_at.hpp │ │ │ │ │ │ │ └── value_at_key.hpp │ │ │ │ │ │ ├── intrinsic.hpp │ │ │ │ │ │ ├── intrinsic_fwd.hpp │ │ │ │ │ │ ├── io/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── in.hpp │ │ │ │ │ │ │ │ ├── manip.hpp │ │ │ │ │ │ │ │ └── out.hpp │ │ │ │ │ │ │ ├── in.hpp │ │ │ │ │ │ │ └── out.hpp │ │ │ │ │ │ ├── io.hpp │ │ │ │ │ │ └── sequence_facade.hpp │ │ │ │ │ ├── sequence.hpp │ │ │ │ │ ├── support/ │ │ │ │ │ │ ├── as_const.hpp │ │ │ │ │ │ ├── category_of.hpp │ │ │ │ │ │ ├── config.hpp │ │ │ │ │ │ ├── deduce.hpp │ │ │ │ │ │ ├── deduce_sequence.hpp │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── access.hpp │ │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ │ ├── as_fusion_element.hpp │ │ │ │ │ │ │ ├── category_of.hpp │ │ │ │ │ │ │ ├── enabler.hpp │ │ │ │ │ │ │ ├── index_sequence.hpp │ │ │ │ │ │ │ ├── is_mpl_sequence.hpp │ │ │ │ │ │ │ ├── is_same_size.hpp │ │ │ │ │ │ │ ├── is_view.hpp │ │ │ │ │ │ │ ├── mpl_iterator_category.hpp │ │ │ │ │ │ │ ├── pp_round.hpp │ │ │ │ │ │ │ ├── segmented_fold_until_impl.hpp │ │ │ │ │ │ │ └── unknown_key.hpp │ │ │ │ │ │ ├── is_iterator.hpp │ │ │ │ │ │ ├── is_segmented.hpp │ │ │ │ │ │ ├── is_sequence.hpp │ │ │ │ │ │ ├── is_view.hpp │ │ │ │ │ │ ├── iterator_base.hpp │ │ │ │ │ │ ├── pair.hpp │ │ │ │ │ │ ├── segmented_fold_until.hpp │ │ │ │ │ │ ├── sequence_base.hpp │ │ │ │ │ │ ├── tag_of.hpp │ │ │ │ │ │ ├── tag_of_fwd.hpp │ │ │ │ │ │ ├── unused.hpp │ │ │ │ │ │ └── void.hpp │ │ │ │ │ ├── support.hpp │ │ │ │ │ ├── tuple/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ │ ├── preprocessed/ │ │ │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ │ │ ├── make_tuple10.hpp │ │ │ │ │ │ │ │ ├── make_tuple20.hpp │ │ │ │ │ │ │ │ ├── make_tuple30.hpp │ │ │ │ │ │ │ │ ├── make_tuple40.hpp │ │ │ │ │ │ │ │ ├── make_tuple50.hpp │ │ │ │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ │ │ │ ├── tuple10.hpp │ │ │ │ │ │ │ │ ├── tuple10_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple20.hpp │ │ │ │ │ │ │ │ ├── tuple20_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple30.hpp │ │ │ │ │ │ │ │ ├── tuple30_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple40.hpp │ │ │ │ │ │ │ │ ├── tuple40_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple50.hpp │ │ │ │ │ │ │ │ ├── tuple50_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple_fwd.hpp │ │ │ │ │ │ │ │ ├── tuple_tie.hpp │ │ │ │ │ │ │ │ ├── tuple_tie10.hpp │ │ │ │ │ │ │ │ ├── tuple_tie20.hpp │ │ │ │ │ │ │ │ ├── tuple_tie30.hpp │ │ │ │ │ │ │ │ ├── tuple_tie40.hpp │ │ │ │ │ │ │ │ └── tuple_tie50.hpp │ │ │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ │ │ ├── tuple_expand.hpp │ │ │ │ │ │ │ ├── tuple_fwd.hpp │ │ │ │ │ │ │ └── tuple_tie.hpp │ │ │ │ │ │ ├── make_tuple.hpp │ │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ │ ├── tuple_fwd.hpp │ │ │ │ │ │ └── tuple_tie.hpp │ │ │ │ │ ├── tuple.hpp │ │ │ │ │ ├── view/ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ └── strictest_traversal.hpp │ │ │ │ │ │ ├── filter_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── filter_view.hpp │ │ │ │ │ │ │ └── filter_view_iterator.hpp │ │ │ │ │ │ ├── filter_view.hpp │ │ │ │ │ │ ├── flatten_view/ │ │ │ │ │ │ │ ├── flatten_view.hpp │ │ │ │ │ │ │ └── flatten_view_iterator.hpp │ │ │ │ │ │ ├── flatten_view.hpp │ │ │ │ │ │ ├── iterator_range/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── is_segmented_impl.hpp │ │ │ │ │ │ │ │ ├── segmented_iterator_range.hpp │ │ │ │ │ │ │ │ ├── segments_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ └── value_at_impl.hpp │ │ │ │ │ │ │ └── iterator_range.hpp │ │ │ │ │ │ ├── iterator_range.hpp │ │ │ │ │ │ ├── joint_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── joint_view.hpp │ │ │ │ │ │ │ ├── joint_view_fwd.hpp │ │ │ │ │ │ │ └── joint_view_iterator.hpp │ │ │ │ │ │ ├── joint_view.hpp │ │ │ │ │ │ ├── nview/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── cpp03/ │ │ │ │ │ │ │ │ │ └── nview_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── nview_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── nview.hpp │ │ │ │ │ │ │ └── nview_iterator.hpp │ │ │ │ │ │ ├── nview.hpp │ │ │ │ │ │ ├── repetitive_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── repetitive_view.hpp │ │ │ │ │ │ │ ├── repetitive_view_fwd.hpp │ │ │ │ │ │ │ └── repetitive_view_iterator.hpp │ │ │ │ │ │ ├── repetitive_view.hpp │ │ │ │ │ │ ├── reverse_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_data_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── key_of_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ ├── value_of_data_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── reverse_view.hpp │ │ │ │ │ │ │ └── reverse_view_iterator.hpp │ │ │ │ │ │ ├── reverse_view.hpp │ │ │ │ │ │ ├── single_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── single_view.hpp │ │ │ │ │ │ │ └── single_view_iterator.hpp │ │ │ │ │ │ ├── single_view.hpp │ │ │ │ │ │ ├── transform_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── apply_transform_result.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── transform_view.hpp │ │ │ │ │ │ │ ├── transform_view_fwd.hpp │ │ │ │ │ │ │ └── transform_view_iterator.hpp │ │ │ │ │ │ ├── transform_view.hpp │ │ │ │ │ │ ├── zip_view/ │ │ │ │ │ │ │ ├── detail/ │ │ │ │ │ │ │ │ ├── advance_impl.hpp │ │ │ │ │ │ │ │ ├── at_impl.hpp │ │ │ │ │ │ │ │ ├── begin_impl.hpp │ │ │ │ │ │ │ │ ├── deref_impl.hpp │ │ │ │ │ │ │ │ ├── distance_impl.hpp │ │ │ │ │ │ │ │ ├── end_impl.hpp │ │ │ │ │ │ │ │ ├── equal_to_impl.hpp │ │ │ │ │ │ │ │ ├── next_impl.hpp │ │ │ │ │ │ │ │ ├── prior_impl.hpp │ │ │ │ │ │ │ │ ├── size_impl.hpp │ │ │ │ │ │ │ │ ├── value_at_impl.hpp │ │ │ │ │ │ │ │ └── value_of_impl.hpp │ │ │ │ │ │ │ ├── zip_view.hpp │ │ │ │ │ │ │ ├── zip_view_iterator.hpp │ │ │ │ │ │ │ └──
Copy disabled (too large)
Download .txt
Showing preview only (119,218K chars total). Download the full file to get everything.
SYMBOL INDEX (144554 symbols across 7376 files)
FILE: android/src/main/java/com/reactnativereceivesharingintent/ReceiveSharingIntentHelper.java
class ReceiveSharingIntentHelper (line 21) | public class ReceiveSharingIntentHelper {
method ReceiveSharingIntentHelper (line 25) | public ReceiveSharingIntentHelper(Application context){
method sendFileNames (line 29) | @RequiresApi(api = Build.VERSION_CODES.KITKAT)
method getMediaUris (line 108) | @RequiresApi(api = Build.VERSION_CODES.KITKAT)
method getMediaType (line 161) | private String getMediaType(String url){
method clearFileNames (line 167) | public void clearFileNames(Intent intent){
method getFileName (line 177) | public String getFileName(String file){
method getExtension (line 181) | public String getExtension(String file){
FILE: android/src/main/java/com/reactnativereceivesharingintent/ReceiveSharingIntentModule.java
class ReceiveSharingIntentModule (line 16) | public class ReceiveSharingIntentModule extends ReactContextBaseJavaModu...
method ReceiveSharingIntentModule (line 22) | public ReceiveSharingIntentModule(ReactApplicationContext reactContext) {
method onNewIntent (line 30) | protected void onNewIntent(Intent intent) {
method getFileNames (line 36) | @RequiresApi(api = Build.VERSION_CODES.KITKAT)
method clearFileNames (line 46) | @ReactMethod
method getName (line 55) | @Override
FILE: docs/src/components/HomepageFeatures.js
function Feature (line 38) | function Feature({Svg, title, description}) {
function HomepageFeatures (line 52) | function HomepageFeatures() {
FILE: docs/src/pages/index.js
function HomepageHeader (line 9) | function HomepageHeader() {
function Home (line 28) | function Home() {
FILE: docs/src/theme/Footer/index.tsx
function FooterLink (line 17) | function FooterLink({
function Footer (line 50) | function Footer(): JSX.Element | null {
FILE: example/android/app/src/debug/java/com/example/reactnativereceivesharingintent/ReactNativeFlipper.java
class ReactNativeFlipper (line 27) | public class ReactNativeFlipper {
method initializeFlipper (line 28) | public static void initializeFlipper(Context context, ReactInstanceMan...
FILE: example/android/app/src/main/java/com/example/reactnativereceivesharingintent/MainActivity.java
class MainActivity (line 8) | public class MainActivity extends ReactActivity {
method onNewIntent (line 15) | @Override
method getMainComponentName (line 22) | @Override
FILE: example/android/app/src/main/java/com/example/reactnativereceivesharingintent/MainApplication.java
class MainApplication (line 17) | public class MainApplication extends Application implements ReactApplica...
method getUseDeveloperSupport (line 21) | @Override
method getPackages (line 26) | @Override
method getJSMainModuleName (line 36) | @Override
method getReactNativeHost (line 42) | @Override
method onCreate (line 47) | @Override
method initializeFlipper (line 59) | private static void initializeFlipper(Context context, ReactInstanceMa...
FILE: example/ios/Pods/DoubleConversion/double-conversion/bignum-dtoa.cc
type double_conversion (line 35) | namespace double_conversion {
function NormalizedExponent (line 37) | static int NormalizedExponent(uint64_t significand, int exponent) {
function BignumDtoa (line 89) | void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
function GenerateShortestDigits (line 185) | static void GenerateShortestDigits(Bignum* numerator, Bignum* denomina...
function GenerateCountedDigits (line 283) | static void GenerateCountedDigits(int count, int* decimal_point,
function BignumToFixed (line 326) | static void BignumToFixed(int requested_digits, int* decimal_point,
function EstimatePower (line 385) | static int EstimatePower(int exponent) {
function InitialScaledStartValuesPositiveExponent (line 417) | static void InitialScaledStartValuesPositiveExponent(
function InitialScaledStartValuesNegativeExponentPositivePower (line 450) | static void InitialScaledStartValuesNegativeExponentPositivePower(
function InitialScaledStartValuesNegativeExponentNegativePower (line 484) | static void InitialScaledStartValuesNegativeExponentNegativePower(
function InitialScaledStartValues (line 568) | static void InitialScaledStartValues(uint64_t significand,
function FixupMultiply10 (line 612) | static void FixupMultiply10(int estimated_power, bool is_even,
FILE: example/ios/Pods/DoubleConversion/double-conversion/bignum-dtoa.h
function namespace (line 33) | namespace double_conversion {
FILE: example/ios/Pods/DoubleConversion/double-conversion/bignum.cc
type double_conversion (line 31) | namespace double_conversion {
function BitSize (line 42) | static int BitSize(S value) {
function ReadUInt64 (line 89) | static uint64_t ReadUInt64(Vector<const char> buffer,
function HexCharValue (line 123) | static int HexCharValue(char c) {
function SizeInHexChars (line 553) | static int SizeInHexChars(S number) {
function HexCharOfValue (line 564) | static char HexCharOfValue(int value) {
FILE: example/ios/Pods/DoubleConversion/double-conversion/bignum.h
function namespace (line 33) | namespace double_conversion {
FILE: example/ios/Pods/DoubleConversion/double-conversion/cached-powers.cc
type double_conversion (line 36) | namespace double_conversion {
type CachedPower (line 38) | struct CachedPower {
FILE: example/ios/Pods/DoubleConversion/double-conversion/cached-powers.h
function namespace (line 33) | namespace double_conversion {
FILE: example/ios/Pods/DoubleConversion/double-conversion/diy-fp.cc
type double_conversion (line 32) | namespace double_conversion {
FILE: example/ios/Pods/DoubleConversion/double-conversion/diy-fp.h
function namespace (line 33) | namespace double_conversion {
FILE: example/ios/Pods/DoubleConversion/double-conversion/double-conversion.cc
type double_conversion (line 40) | namespace double_conversion {
function DoubleToStringConverter (line 42) | const DoubleToStringConverter& DoubleToStringConverter::EcmaScriptConv...
function BignumDtoaMode (line 341) | static BignumDtoaMode DtoaToBignumDtoaMode(
function ConsumeSubString (line 419) | static bool ConsumeSubString(const char** current,
function AdvanceToNonspace (line 443) | static inline bool AdvanceToNonspace(const char** current, const char*...
function isDigit (line 452) | static bool isDigit(int x, int radix) {
function SignedZero (line 459) | static double SignedZero(bool sign) {
function IsDecimalDigitForRadix (line 470) | static bool IsDecimalDigitForRadix(int c, int radix) {
function IsCharacterDigitForRadix (line 481) | static bool IsCharacterDigitForRadix(int c, int radix, char a_characte...
function RadixStringToIeee (line 488) | static double RadixStringToIeee(const char* current,
FILE: example/ios/Pods/DoubleConversion/double-conversion/double-conversion.h
function namespace (line 33) | namespace double_conversion {
function class (line 381) | class StringToDoubleConverter {
function StringToFloat (line 512) | float StringToFloat(const char* buffer,
FILE: example/ios/Pods/DoubleConversion/double-conversion/fast-dtoa.cc
type double_conversion (line 34) | namespace double_conversion {
function RoundWeed (line 61) | static bool RoundWeed(Vector<char> buffer,
function RoundWeedCounted (line 181) | static bool RoundWeedCounted(Vector<char> buffer,
function BiggestPowerTen (line 240) | static void BiggestPowerTen(uint32_t number,
function DigitGen (line 300) | static bool DigitGen(DiyFp low,
function DigitGenCounted (line 428) | static bool DigitGenCounted(DiyFp w,
function Grisu3 (line 519) | static bool Grisu3(double v,
function Grisu3Counted (line 591) | static bool Grisu3Counted(double v,
function FastDtoa (line 635) | bool FastDtoa(double v,
FILE: example/ios/Pods/DoubleConversion/double-conversion/fast-dtoa.h
function namespace (line 33) | namespace double_conversion {
FILE: example/ios/Pods/DoubleConversion/double-conversion/fixed-dtoa.cc
type double_conversion (line 33) | namespace double_conversion {
class UInt128 (line 37) | class UInt128 {
method UInt128 (line 39) | UInt128() : high_bits_(0), low_bits_(0) { }
method UInt128 (line 40) | UInt128(uint64_t high, uint64_t low) : high_bits_(high), low_bits_(l...
method Multiply (line 42) | void Multiply(uint32_t multiplicand) {
method Shift (line 59) | void Shift(int shift_amount) {
method DivModPowerOf2 (line 82) | int DivModPowerOf2(int power) {
method IsZero (line 97) | bool IsZero() const {
method BitAt (line 101) | int BitAt(int position) {
function FillDigits32FixedLength (line 120) | static void FillDigits32FixedLength(uint32_t number, int requested_len...
function FillDigits32 (line 130) | static void FillDigits32(uint32_t number, Vector<char> buffer, int* le...
function FillDigits64FixedLength (line 153) | static void FillDigits64FixedLength(uint64_t number,
function FillDigits64 (line 168) | static void FillDigits64(uint64_t number, Vector<char> buffer, int* le...
function RoundUp (line 189) | static void RoundUp(Vector<char> buffer, int* length, int* decimal_poi...
function FillFractionals (line 230) | static void FillFractionals(uint64_t fractionals, int exponent,
function TrimZeros (line 291) | static void TrimZeros(Vector<char> buffer, int* length, int* decimal_p...
function FastFixedDtoa (line 309) | bool FastFixedDtoa(double v,
FILE: example/ios/Pods/DoubleConversion/double-conversion/fixed-dtoa.h
function namespace (line 33) | namespace double_conversion {
FILE: example/ios/Pods/DoubleConversion/double-conversion/ieee.h
function namespace (line 33) | namespace double_conversion {
function IsDenormal (line 131) | bool IsDenormal() const {
function IsNan (line 143) | bool IsNan() const {
function DiyFp (line 162) | DiyFp UpperBoundary() const {
function SignificandSizeForOrderOfMagnitude (line 208) | static int SignificandSizeForOrderOfMagnitude(int order) {
function Infinity (line 216) | static double Infinity() {
function NaN (line 220) | static double NaN() {
function DiyFpToUint64 (line 233) | static uint64_t DiyFpToUint64(DiyFp diy_fp) {
function class (line 263) | class Single {
function IsDenormal (line 309) | bool IsDenormal() const {
function IsNan (line 321) | bool IsNan() const {
function NormalizedBoundaries (line 342) | void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const {
function DiyFp (line 360) | DiyFp UpperBoundary() const {
function Infinity (line 380) | static float Infinity() {
function NaN (line 384) | static float NaN() {
FILE: example/ios/Pods/DoubleConversion/double-conversion/strtod.cc
type double_conversion (line 36) | namespace double_conversion {
function TrimLeadingZeros (line 91) | static Vector<const char> TrimLeadingZeros(Vector<const char> buffer) {
function TrimTrailingZeros (line 101) | static Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
function CutToMaxSignificantDigits (line 111) | static void CutToMaxSignificantDigits(Vector<const char> buffer,
function TrimAndCut (line 133) | static void TrimAndCut(Vector<const char> buffer, int exponent,
function ReadUint64 (line 158) | static uint64_t ReadUint64(Vector<const char> buffer,
function ReadDiyFp (line 176) | static void ReadDiyFp(Vector<const char> buffer,
function DoubleStrtod (line 197) | static bool DoubleStrtod(Vector<const char> trimmed,
function DiyFp (line 251) | static DiyFp AdjustmentPowerOfTen(int exponent) {
function DiyFpStrtod (line 274) | static bool DiyFpStrtod(Vector<const char> buffer,
function CompareBufferWithDiyFp (line 392) | static int CompareBufferWithDiyFp(Vector<const char> buffer,
function ComputeGuess (line 423) | static bool ComputeGuess(Vector<const char> trimmed, int exponent,
function Strtod (line 448) | double Strtod(Vector<const char> buffer, int exponent) {
function Strtof (line 474) | float Strtof(Vector<const char> buffer, int exponent) {
FILE: example/ios/Pods/DoubleConversion/double-conversion/strtod.h
function namespace (line 33) | namespace double_conversion {
FILE: example/ios/Pods/DoubleConversion/double-conversion/utils.h
type __int64 (line 93) | typedef __int64 int64_t;
function namespace (line 139) | namespace double_conversion {
FILE: example/ios/Pods/Folly/folly/AtomicHashArray-inl.h
function namespace (line 28) | namespace folly {
type typename (line 209) | typedef
function try (line 376) | try {
function aha_ (line 493) | aha_(nullptr) {}
function explicit (line 505) | explicit aha_iterator(ContT* array, size_t offset)
function advancePastEmpty (line 515) | void advancePastEmpty() {
function increment (line 526) | void increment() {
function equal (line 531) | bool equal(const aha_iterator& o) const {
FILE: example/ios/Pods/Folly/folly/AtomicHashArray.h
function namespace (line 41) | namespace folly {
FILE: example/ios/Pods/Folly/folly/AtomicHashMap-inl.h
function namespace (line 26) | namespace folly {
function ahm_ (line 576) | ahm_(nullptr) {}
function increment (line 605) | void increment() {
function equal (line 611) | bool equal(const ahm_iterator& other) const {
function checkAdvanceToNextSubmap (line 631) | void checkAdvanceToNextSubmap() {
FILE: example/ios/Pods/Folly/folly/AtomicHashMap.h
function namespace (line 96) | namespace folly {
function iterator (line 379) | iterator begin() {
function const_iterator (line 385) | const_iterator begin() const {
function value_type (line 430) | inline const value_type& idxToRec(uint32_t idx) const {
type SimpleRetT (line 448) | struct SimpleRetT {
function tryLockMap (line 475) | inline bool tryLockMap(unsigned int idx) {
FILE: example/ios/Pods/Folly/folly/AtomicIntrusiveLinkedList.h
function T (line 40) | T* next{nullptr};
function insertHead (line 80) | bool insertHead(T* t) {
function T (line 148) | static T*& next(T* t) {
function T (line 154) | static T* reverse(T* head) {
FILE: example/ios/Pods/Folly/folly/AtomicLinkedList.h
function namespace (line 22) | namespace folly {
type Wrapper (line 99) | struct Wrapper {
FILE: example/ios/Pods/Folly/folly/AtomicUnorderedMap.h
function namespace (line 36) | namespace folly {
function const_iterator (line 319) | const_iterator find(const Key& key) const {
function const_iterator (line 323) | const_iterator cbegin() const {
type IndexType (line 336) | enum : IndexType {
function IndexType (line 340) | enum BucketState : IndexType {
function stateUpdate (line 379) | void stateUpdate(BucketState before, BucketState after) {
function value_type (line 389) | const value_type& keyValue() const {
function IndexType (line 417) | IndexType find(const Key& key, IndexType slot) const {
function IndexType (line 430) | IndexType allocateNear(IndexType start) {
function IndexType (line 446) | IndexType allocationAttempt(IndexType start, IndexType tries) const {
function zeroFillSlots (line 461) | void zeroFillSlots() {
function explicit (line 501) | explicit MutableAtom(const T& init) : data(init) {}
function explicit (line 510) | explicit MutableData(const T& init) : data(init) {}
FILE: example/ios/Pods/Folly/folly/Benchmark.h
function namespace (line 38) | namespace folly {
function doNotOptimizeDependencySink (line 284) | inline void doNotOptimizeDependencySink(const void*) {}
function namespace (line 300) | namespace detail {
type dynamic (line 354) | struct dynamic
FILE: example/ios/Pods/Folly/folly/CachelinePadded.h
function T (line 49) | T* get() {
function T (line 53) | const T* get() const {
function T (line 61) | const T* operator->() const {
FILE: example/ios/Pods/Folly/folly/CancellationToken-inl.h
function namespace (line 24) | namespace folly {
function swap (line 146) | inline void CancellationToken::swap(CancellationToken& other) noexcept {
function CancellationToken (line 150) | inline CancellationToken::CancellationToken(
function CancellationSource (line 169) | inline CancellationSource::CancellationSource(
function CancellationSource (line 177) | inline CancellationSource::CancellationSource(
function CancellationSource (line 196) | inline CancellationSource CancellationSource::invalid() noexcept {
function CancellationToken (line 208) | inline CancellationToken CancellationSource::getToken() const noexcept {
function swap (line 222) | inline void CancellationSource::swap(CancellationSource& other) noexcept {
function CancellationSource (line 226) | inline CancellationSource::CancellationSource(
function invokeCallback (line 276) | inline void CancellationCallback::invokeCallback() noexcept {
function namespace (line 281) | namespace detail {
FILE: example/ios/Pods/Folly/folly/CancellationToken.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Chrono.h
function namespace (line 36) | namespace folly {
function namespace (line 48) | namespace folly {
function namespace (line 174) | namespace folly {
FILE: example/ios/Pods/Folly/folly/ClockGettimeWrappers.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/ConcurrentBitSet.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/ConcurrentSkipList-inl.h
function namespace (line 37) | namespace folly {
FILE: example/ios/Pods/Folly/folly/ConcurrentSkipList.h
function namespace (line 136) | namespace folly {
function std (line 186) | static std::shared_ptr<SkipListType> createInstance(
function less (line 218) | static bool less(const value_type& data, const NodeType* node) {
function findInsertionPoint (line 222) | static int findInsertionPoint(
function incrementSize (line 263) | size_t incrementSize(int delta) {
function NodeType (line 268) | NodeType* find(const value_type& data) {
function remove (line 367) | bool remove(const value_type& data) {
function value_type (line 409) | const value_type* first() const {
function value_type (line 414) | const value_type* last() const {
function okToDelete (line 429) | static bool okToDelete(NodeType* candidate, int layer) {
function findInsertionPointGetMaxLayer (line 436) | int findInsertionPointGetMaxLayer(
function NodeType (line 502) | NodeType* lower_bound(const value_type& data) const {
function growHeight (line 510) | void growHeight(int height) {
function recycle (line 535) | void recycle(NodeType* node) {
type detail (line 546) | typedef detail::SkipListNode<T> NodeType;
type ConcurrentSkipList (line 547) | typedef ConcurrentSkipList<T, Comp, NodeAlloc, MAX_HEIGHT> SkipListType;
type T (line 551) | typedef T key_type;
type T (line 552) | typedef T& reference;
type T (line 553) | typedef T* pointer;
type T (line 554) | typedef const T& const_reference;
type T (line 555) | typedef const T* const_pointer;
type size_type (line 556) | typedef size_t size_type;
type Comp (line 557) | typedef Comp key_compare;
type Comp (line 558) | typedef Comp value_compare;
type typename (line 560) | typedef typename SkipListType::iterator iterator;
type typename (line 561) | typedef typename SkipListType::const_iterator const_iterator;
type typename (line 562) | typedef typename SkipListType::Skipper Skipper;
function explicit (line 564) | explicit Accessor(std::shared_ptr<ConcurrentSkipList> skip_list)
function explicit (line 573) | explicit Accessor(ConcurrentSkipList* skip_list) : sl_(skip_list) {
function size_type (line 603) | size_type max_size() const {
function const_iterator (line 613) | const_iterator find(const key_type& value) const {
function size_type (line 616) | size_type count(const key_type& data) const {
function iterator (line 620) | iterator begin() const {
function erase (line 642) | size_t erase(const key_type& data) {
function iterator (line 646) | iterator lower_bound(const key_type& data) const {
function key_type (line 665) | const key_type* first() const {
function key_type (line 668) | const key_type* last() const {
function pop_back (line 677) | bool pop_back() {
function SkipListType (line 687) | SkipListType* skiplist() const {
function contains (line 695) | bool contains(const key_type& data) const {
function add (line 698) | bool add(const key_type& data) {
function remove (line 701) | bool remove(const key_type& data) {
type value_type (line 718) | typedef value_type& reference;
type value_type (line 719) | typedef value_type* pointer;
type difference_type (line 720) | typedef ptrdiff_t difference_type;
function increment (line 746) | void increment() {
function equal (line 749) | bool equal(const csl_iterator& other) const {
type detail (line 762) | typedef detail::SkipListNode<T> NodeType;
type ConcurrentSkipList (line 763) | typedef ConcurrentSkipList<T, Comp, NodeAlloc, MAX_HEIGHT> SkipListType;
type typename (line 764) | typedef typename SkipListType::Accessor Accessor;
type T (line 768) | typedef T& reference;
type T (line 769) | typedef T* pointer;
type difference_type (line 770) | typedef ptrdiff_t difference_type;
function accessor_ (line 776) | Skipper(const Accessor& accessor) : accessor_(accessor) {
function init (line 780) | void init() {
function value_type (line 822) | const value_type& data() const {
function to (line 843) | bool to(const value_type& data) {
FILE: example/ios/Pods/Folly/folly/ConstexprMath.h
function namespace (line 24) | namespace folly {
function namespace (line 102) | namespace detail {
function constexpr_find_last_set (line 150) | size_t constexpr_find_last_set(T const t) {
function namespace (line 155) | namespace detail {
function constexpr_find_first_set (line 170) | size_t constexpr_find_first_set(T t) {
function namespace (line 304) | namespace detail {
FILE: example/ios/Pods/Folly/folly/Conv.cpp
type folly (line 20) | namespace folly {
type detail (line 21) | namespace detail {
type MaxString (line 50) | struct MaxString {
type ErrorString (line 212) | struct ErrorString {
function tolower_ascii (line 244) | inline char tolower_ascii(char in) {
function bool_str_cmp (line 248) | inline bool bool_str_cmp(const char** b, size_t len, const char* val...
function str_to_bool (line 267) | Expected<bool, ConversionCode> str_to_bool(StringPiece* src) noexcept {
function str_to_floating (line 344) | Expected<Tgt, ConversionCode> str_to_floating(StringPiece* src) noex...
class SignedValueHandler (line 465) | class SignedValueHandler
class SignedValueHandler<T, true> (line 468) | class SignedValueHandler<T, true> {
method ConversionCode (line 470) | ConversionCode init(const char*& b) {
method ConversionCode (line 483) | ConversionCode overflow() {
method finalize (line 489) | Expected<T, ConversionCode> finalize(U value) {
class SignedValueHandler<T, false> (line 511) | class SignedValueHandler<T, false> {
method ConversionCode (line 513) | ConversionCode init(const char*&) {
method ConversionCode (line 517) | ConversionCode overflow() {
method finalize (line 521) | Expected<T, ConversionCode> finalize(T value) {
function digits_to (line 534) | inline Expected<Tgt, ConversionCode> digits_to(
function str_to_integral (line 684) | Expected<Tgt, ConversionCode> str_to_integral(StringPiece* src) noex...
function ConversionError (line 766) | ConversionError makeConversionError(ConversionCode code, StringPiece i...
FILE: example/ios/Pods/Folly/folly/Conv.h
function namespace (line 128) | namespace folly {
function estimateSpaceNeeded (line 543) | inline size_t estimateSpaceNeeded(std::nullptr_t /* value */) {
type typename (line 704) | typedef
type typename (line 716) | typedef
function estimateSpaceNeeded (line 849) | size_t>::type
function namespace (line 854) | namespace detail {
function namespace (line 1105) | namespace detail {
function typename (line 1460) | typename std::underlying_type<T>::type tmp{}
function namespace (line 1492) | namespace detail {
function Tgt (line 1572) | Tgt result{}
function Tgt (line 1606) | Tgt result{}
function Error (line 1614) | Error e) { return makeConversionError(e, *src); }
FILE: example/ios/Pods/Folly/folly/CpuId.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/DefaultKeepAliveExecutor.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Demangle.cpp
type folly (line 32) | namespace folly {
function fbstring (line 36) | fbstring demangle(const char* name) {
type DemangleBuf (line 66) | struct DemangleBuf {
function demangleCallback (line 72) | void demangleCallback(const char* str, size_t size, void* p) {
function demangle (line 83) | size_t demangle(const char* name, char* out, size_t outSize) {
function fbstring (line 115) | fbstring demangle(const char* name) {
function demangle (line 119) | size_t demangle(const char* name, char* out, size_t outSize) {
FILE: example/ios/Pods/Folly/folly/Demangle.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/DiscriminatedPtr.h
function namespace (line 42) | namespace folly {
function clear (line 147) | void clear() {
function set (line 210) | void set(void* p, uint16_t v) {
FILE: example/ios/Pods/Folly/folly/DynamicConverter.h
function namespace (line 34) | namespace folly {
function namespace (line 54) | namespace folly {
function C (line 266) | static C convert(const dynamic& d) {
function C (line 288) | static C convert(const dynamic& d) {
function dynamic (line 317) | static dynamic construct(const C& x) {
function dynamic (line 327) | static dynamic construct(const C& x) {
function dynamic (line 337) | static dynamic construct(const C& x) {
function dynamic (line 349) | static dynamic construct(const C& x) {
function dynamic (line 367) | static dynamic construct(const C& x) {
function dynamic (line 379) | static dynamic construct(const std::pair<A, B>& x) {
type DynamicConstructor (line 389) | struct DynamicConstructor
function dynamic (line 390) | static dynamic construct(const std::vector<bool>& x) {
FILE: example/ios/Pods/Folly/folly/Exception.h
function namespace (line 30) | namespace folly {
function throwSystemErrorExplicit (line 65) | [[noreturn]] inline void throwSystemErrorExplicit(int err, const char* m...
function throwSystemErrorExplicit (line 70) | [[noreturn]] void throwSystemErrorExplicit(int err, Args&&... args) {
function throwSystemError (line 76) | [[noreturn]] void throwSystemError(Args&&... args) {
FILE: example/ios/Pods/Folly/folly/ExceptionString.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/ExceptionWrapper-inl.h
function namespace (line 24) | namespace folly {
function std (line 86) | inline std::exception const* exception_wrapper::as_exception_or_null_(
function std (line 90) | inline std::exception const* exception_wrapper::as_exception_or_null_(
function as_int_ (line 100) | inline std::uintptr_t exception_wrapper::ExceptionPtr::as_int_(
function as_int_ (line 131) | inline std::uintptr_t exception_wrapper::ExceptionPtr::as_int_(
function std (line 139) | inline std::exception const* exception_wrapper::ExceptionPtr::as_excepti...
function std (line 143) | inline std::type_info const* exception_wrapper::ExceptionPtr::as_type_()...
function copy_ (line 147) | inline void exception_wrapper::ExceptionPtr::copy_(
function move_ (line 152) | inline void exception_wrapper::ExceptionPtr::move_(
function delete_ (line 158) | inline void exception_wrapper::ExceptionPtr::delete_(exception_wrapper* ...
function throw_ (line 162) | [[noreturn]] inline void exception_wrapper::ExceptionPtr::throw_(
function std (line 166) | inline std::type_info const* exception_wrapper::ExceptionPtr::type_(
function std (line 173) | inline std::exception const* exception_wrapper::ExceptionPtr::get_except...
function exception_wrapper (line 177) | inline exception_wrapper exception_wrapper::ExceptionPtr::get_exception_...
function throw_ (line 203) | [[noreturn]] inline void exception_wrapper::InPlace<Ex>::throw_(
function noexcept (line 234) | const noexcept {
function exception_wrapper (line 238) | exception_wrapper
function copy_ (line 246) | inline void exception_wrapper::SharedPtr::copy_(
function move_ (line 251) | inline void exception_wrapper::SharedPtr::move_(
function delete_ (line 258) | inline void exception_wrapper::SharedPtr::delete_(exception_wrapper* tha...
function throw_ (line 262) | [[noreturn]] inline void exception_wrapper::SharedPtr::throw_(
function std (line 267) | inline std::type_info const* exception_wrapper::SharedPtr::type_(
function std (line 271) | inline std::exception const* exception_wrapper::SharedPtr::get_exception_(
function exception_wrapper (line 275) | inline exception_wrapper exception_wrapper::SharedPtr::get_exception_ptr_(
function exception_wrapper (line 305) | inline exception_wrapper::exception_wrapper(exception_wrapper&& that) no...
function exception_wrapper (line 310) | inline exception_wrapper::exception_wrapper(
function exception_wrapper (line 332) | inline exception_wrapper::~exception_wrapper() {
function namespace (line 344) | namespace exception_wrapper_detail {
function swap (line 385) | inline void exception_wrapper::swap(exception_wrapper& that) noexcept {
function exception_wrapper (line 395) | inline bool exception_wrapper::operator!() const noexcept {
function reset (line 399) | inline void exception_wrapper::reset() {
function std (line 407) | inline std::exception* exception_wrapper::get_exception() noexcept {
function std (line 410) | inline std::exception const* exception_wrapper::get_exception() const no...
function Ex (line 416) | Ex* object{nullptr};
function Ex (line 422) | Ex const* exception_wrapper::get_exception() const noexcept {
function impl (line 603) | auto impl = exception_wrapper_detail::fold(
function continuation (line 612) | auto continuation = [](StdEx* ex) { return ex; }
FILE: example/ios/Pods/Folly/folly/ExceptionWrapper.h
function namespace (line 53) | namespace folly {
function class (line 162) | class exception_wrapper final {
function VTable (line 343) | VTable const* vptr_{&uninit_};
FILE: example/ios/Pods/Folly/folly/Executor.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Expected.h
function namespace (line 55) | namespace folly {
FILE: example/ios/Pods/Folly/folly/FBString.h
function FOLLY_PUSH_WARNING (line 50) | FOLLY_PUSH_WARNING
function AcquireMallocatedString (line 141) | enum class AcquireMallocatedString {}
function else (line 285) | else if (size <= maxMediumSize) {
function swap (line 332) | void swap(fbstring_core& rhs) {
function Char (line 339) | const Char* data() const {
function Char (line 343) | Char* data() {
function Char (line 347) | Char* mutableData() {
function Char (line 359) | const Char* c_str() const {
function shrink (line 366) | void shrink(const size_t delta) {
function FOLLY_NOINLINE (line 377) | FOLLY_NOINLINE
function push_back (line 400) | void push_back(Char c) {
function size (line 404) | size_t size() const {
function reset (line 451) | void reset() {
function FOLLY_NOINLINE (line 455) | FOLLY_NOINLINE void destroyMediumLarge() noexcept {
type RefCounted (line 465) | struct RefCounted {
function refs (line 479) | static size_t refs(Char* p) {
function incrementRefs (line 483) | static void incrementRefs(Char* p) {
function decrementRefs (line 487) | static void decrementRefs(Char* p) {
function RefCounted (line 496) | static RefCounted* create(size_t* size) {
function RefCounted (line 505) | static RefCounted* create(const Char* data, size_t* size) {
function RefCounted (line 514) | static RefCounted* reallocate(
type category_type (line 535) | typedef uint8_t category_type;
function category_type (line 537) | enum class Category : category_type {
function setSmallSize (line 591) | void setSmallSize(size_t s) {
function copyMedium (line 641) | void fbstring_core<Char>::copyMedium(
function initMedium (line 713) | void fbstring_core<Char>::initMedium(
function reserveLarge (line 767) | void fbstring_core<Char>::reserveLarge(
function reserveSmall (line 824) | void fbstring_core<Char>::reserveSmall(
function backend_ (line 926) | dummy_fbstring_core(const dummy_fbstring_core& another)
function Char (line 932) | const Char* data() const {
function Char (line 935) | Char* mutableData() {
function shrink (line 938) | void shrink(size_t delta) {
function Char (line 942) | Char* expandNoinit(size_t delta) {
function push_back (line 947) | void push_back(Char c) {
function reserve (line 959) | void reserve(size_t minCapacity) {
function enforce (line 979) | void enforce(bool condition, Args&&... args) {
function explicit (line 994) | explicit Invariant(const basic_fbstring& s) noexcept : s_(s) {
type typename (line 1008) | typedef typename traits_type::char_type value_type;
type A (line 1009) | typedef A allocator_type;
type typename (line 1010) | typedef typename A::size_type size_type;
type typename (line 1011) | typedef typename A::difference_type difference_type;
type typename (line 1013) | typedef typename A::reference reference;
type typename (line 1014) | typedef typename A::const_reference const_reference;
type typename (line 1015) | typedef typename A::pointer pointer;
type typename (line 1016) | typedef typename A::const_pointer const_pointer;
type E (line 1018) | typedef E* iterator;
type E (line 1019) | typedef const E* const_iterator;
type std (line 1020) | typedef std::reverse_iterator<iterator> reverse_iterator;
type std (line 1021) | typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
type std (line 1024) | typedef std::true_type IsRelocatable;
function explicit (line 1052) | explicit basic_fbstring(const A&) noexcept {}
function store_ (line 1054) | basic_fbstring(const basic_fbstring& str) : store_(str.store_) {}
function FOLLY_NOINLINE (line 1073) | FOLLY_NOINLINE
function FOLLY_NOINLINE (line 1077) | FOLLY_NOINLINE
function FOLLY_NOINLINE (line 1081) | FOLLY_NOINLINE
function FOLLY_NOINLINE (line 1099) | FOLLY_NOINLINE
function FOLLY_NOINLINE (line 1112) | FOLLY_NOINLINE
function iterator (line 1171) | iterator begin() {
function iterator (line 1183) | iterator end() {
function reverse_iterator (line 1195) | reverse_iterator rbegin() {
function reverse_iterator (line 1207) | reverse_iterator rend() {
function pop_back (line 1237) | void pop_back() {
function size_type (line 1251) | size_type max_size() const {
function shrink_to_fit (line 1266) | void shrink_to_fit() {
function clear (line 1274) | void clear() {
function const_reference (line 1283) | const_reference operator[](size_type pos) const {
function reference (line 1287) | reference operator[](size_type pos) {
function const_reference (line 1291) | const_reference at(size_type n) const {
function reference (line 1296) | reference at(size_type n) {
function push_back (line 1343) | void push_back(const value_type c) { // primitive
function iterator (line 1406) | iterator insert(const_iterator p, const value_type c) {
function iterator (line 1455) | iterator insert(const_iterator p, std::initializer_list<value_type> il) {
function iterator (line 1469) | iterator erase(iterator position) {
function iterator (line 1476) | iterator erase(iterator first, iterator last) {
function swap (line 1612) | void swap(basic_fbstring& rhs) {
function value_type (line 1616) | const value_type* c_str() const {
function value_type (line 1620) | const value_type* data() const {
function value_type (line 1624) | value_type* data() {
function size_type (line 1647) | size_type rfind(const basic_fbstring& str, size_type pos = npos) const {
function size_type (line 1653) | size_type rfind(const value_type* s, size_type pos = npos) const {
function size_type (line 1657) | size_type rfind(value_type c, size_type pos = npos) const {
function size_type (line 1676) | size_type find_last_of(const basic_fbstring& str, size_type pos = npos)
function size_type (line 1683) | size_type find_last_of(const value_type* s, size_type pos = npos) const {
function size_type (line 1687) | size_type find_last_of(value_type c, size_type pos = npos) const {
function size_type (line 1707) | size_type find_last_not_of(const basic_fbstring& str, size_type pos = npos)
function size_type (line 1715) | size_type find_last_not_of(const value_type* s, size_type pos = npos) co...
function size_type (line 1719) | size_type find_last_not_of(value_type c, size_type pos = npos) const {
function compare (line 1737) | int compare(const basic_fbstring& str) const {
function compare (line 1742) | int compare(size_type pos1, size_type n1, const basic_fbstring& str) con...
function compare (line 1746) | int compare(size_type pos1, size_type n1, const value_type* s) const {
function compare (line 1750) | int compare(size_type pos1, size_type n1, const value_type* s, size_type...
function compare (line 1759) | int compare(
function compare (line 1771) | int compare(const value_type* s) const {
type typename (line 2452) | typedef typename basic_fbstring<E, T, A, S>::size_type size_type;
type typename (line 2453) | typedef typename basic_fbstring<E, T, A, S>::traits_type traits_type;
type std (line 2685) | typedef std::ostreambuf_iterator<
type streamsize (line 2704) | typedef decltype(os.precision()) streamsize;
type basic_fbstring (line 2803) | typedef basic_fbstring<char> fbstring;
function namespace (line 2828) | namespace std {
function namespace (line 2841) | namespace folly {
FILE: example/ios/Pods/Folly/folly/FBVector.h
function namespace (line 48) | namespace folly {
function namespace (line 75) | namespace folly {
function M_destroy (line 330) | void M_destroy(T* p) noexcept {
function D_destroy_range_a (line 355) | void D_destroy_range_a(T* first, T* last) noexcept {
function S_destroy_range_a (line 364) | static void S_destroy_range_a(Allocator& a, T* first, T* last) noexcept {
function S_destroy_range (line 371) | static void S_destroy_range(T* first, T* last) noexcept {
function M_uninitialized_fill_n_e (line 394) | void M_uninitialized_fill_n_e(size_type sz) {
function M_uninitialized_fill_n_e (line 399) | void M_uninitialized_fill_n_e(size_type sz, VT value) {
function D_uninitialized_fill_n_a (line 405) | void D_uninitialized_fill_n_a(T* dest, size_type sz) {
function D_uninitialized_fill_n_a (line 413) | void D_uninitialized_fill_n_a(T* dest, size_type sz, VT value) {
function rollback (line 430) | auto rollback = makeGuard([&] { S_destroy_range_a(a, dest, b); }
function S_uninitialized_fill_n (line 439) | static void S_uninitialized_fill_n(T* dest, size_type n) {
function S_uninitialized_fill_n (line 460) | static void S_uninitialized_fill_n(T* dest, size_type n, const T& value) {
function rollback (line 513) | auto rollback = makeGuard([&] { S_destroy_range_a(a, dest, b); }
function rollback (line 524) | auto rollback = makeGuard([&] { S_destroy_range(dest, b); }
function S_uninitialized_copy_bits (line 531) | static void
function S_uninitialized_copy_bits (line 538) | static void S_uninitialized_copy_bits(
function T (line 570) | static const T* S_copy_n(T* dest, const T* first, size_type n) {
function std (line 579) | static std::move_iterator<T*>
type bool_constant (line 636) | typedef bool_constant<folly::IsRelocatable<T>::value && usingStdAllocator>
type relocate_use_move (line 639) | typedef bool_constant<
function relocate_move (line 645) | void relocate_move(T* dest, T* first, T* last) {
function relocate_move_or_memcpy (line 649) | void relocate_move_or_memcpy(T* dest, T* first, T* last, std::true_type) {
function relocate_move_or_memcpy (line 655) | void relocate_move_or_memcpy(T* dest, T* first, T* last, std::false_type) {
function relocate_move_or_copy (line 659) | void relocate_move_or_copy(T* dest, T* first, T* last, std::true_type) {
function relocate_move_or_copy (line 663) | void relocate_move_or_copy(T* dest, T* first, T* last, std::false_type) {
function relocate_done (line 668) | void relocate_done(T* /*dest*/, T* first, T* last) noexcept {
function relocate_undo (line 677) | void relocate_undo(T* dest, T* first, T* last) noexcept {
function explicit (line 699) | explicit fbvector(const Allocator& a) : impl_(a) {}
function impl_ (line 717) | fbvector(const fbvector& other)
function fbvector (line 726) | fbvector(const fbvector& other, const Allocator& a)
function impl_ (line 729) | impl_(a) {
function impl_ (line 829) | impl_(a) {
function moveFrom (line 836) | void moveFrom(fbvector&& other, std::true_type) {
function moveFrom (line 839) | void moveFrom(fbvector&& other, std::false_type) {
function dataIsInternalAndNotVT (line 884) | bool dataIsInternalAndNotVT(const T& t) {
function dataIsInternal (line 890) | bool dataIsInternal(const T& t) {
function iterator (line 905) | iterator end() noexcept {
function reverse_iterator (line 911) | reverse_iterator rbegin() noexcept {
function const_reverse_iterator (line 914) | const_reverse_iterator rbegin() const noexcept {
function const_reverse_iterator (line 920) | const_reverse_iterator rend() const noexcept {
function const_reverse_iterator (line 930) | const_reverse_iterator crbegin() const noexcept {
function resize (line 950) | void resize(size_type n) {
function resize (line 959) | void resize(size_type n, VT t) {
function reserve (line 980) | void reserve(size_type n) {
function shrink_to_fit (line 1003) | void shrink_to_fit() noexcept {
function const_reference (line 1085) | const_reference operator[](size_type n) const {
function const_reference (line 1089) | const_reference at(size_type n) const {
function reference (line 1096) | reference at(size_type n) {
function reference (line 1100) | reference front() {
function reference (line 1108) | reference back() {
function T (line 1124) | const T* data() const noexcept {
function push_back (line 1143) | void push_back(const T& value) {
function push_back (line 1152) | void push_back(T&& value) {
function pop_back (line 1161) | void pop_back() {
function swap (line 1167) | void swap(fbvector& other) noexcept {
function clear (line 1175) | void clear() noexcept {
function rollback1 (line 1249) | auto rollback1 = makeGuard([&] { M_deallocate(newB, sz); }
function rollback2 (line 1262) | auto rollback2 = makeGuard([&] { M_destroy(newE - 1); }
function iterator (line 1284) | iterator erase(const_iterator first, const_iterator last) {
function size_type (line 1321) | size_type computeInsertCapacity(size_type n) {
function make_window (line 1382) | void make_window(iterator position, size_type n) {
function undo_window (line 1413) | void undo_window(iterator position, size_type n) noexcept {
function wrap_frame (line 1421) | void wrap_frame(T* ledge, size_type idx, size_type n) {
function insert_use_fresh (line 1440) | bool insert_use_fresh(bool at_end, size_type n) {
function rollback (line 1504) | auto rollback = makeGuard([&] {
function rollback (line 1522) | auto rollback = makeGuard([&] {
function iterator (line 1554) | iterator insert(const_iterator cpos, const T& value) {
function iterator (line 1564) | iterator insert(const_iterator cpos, T&& value) {
function iterator (line 1574) | iterator insert(const_iterator cpos, size_type n, VT value) {
function iterator (line 1591) | iterator insert(const_iterator cpos, std::initializer_list<T> il) {
function namespace (line 1687) | namespace detail {
FILE: example/ios/Pods/Folly/folly/File.h
function namespace (line 32) | namespace folly {
FILE: example/ios/Pods/Folly/folly/FileUtil.cpp
type folly (line 32) | namespace folly {
function openNoInt (line 36) | int openNoInt(const char* name, int flags, mode_t mode) {
function filterCloseReturn (line 40) | static int filterCloseReturn(int r) {
function closeNoInt (line 56) | int closeNoInt(int fd) {
function closeNoInt (line 60) | int closeNoInt(NetworkSocket fd) {
function fsyncNoInt (line 64) | int fsyncNoInt(int fd) {
function dupNoInt (line 68) | int dupNoInt(int fd) {
function dup2NoInt (line 72) | int dup2NoInt(int oldfd, int newfd) {
function fdatasyncNoInt (line 76) | int fdatasyncNoInt(int fd) {
function ftruncateNoInt (line 86) | int ftruncateNoInt(int fd, off_t len) {
function truncateNoInt (line 90) | int truncateNoInt(const char* path, off_t len) {
function flockNoInt (line 94) | int flockNoInt(int fd, int operation) {
function shutdownNoInt (line 98) | int shutdownNoInt(NetworkSocket fd, int how) {
function readNoInt (line 102) | ssize_t readNoInt(int fd, void* buf, size_t count) {
function preadNoInt (line 106) | ssize_t preadNoInt(int fd, void* buf, size_t count, off_t offset) {
function readvNoInt (line 110) | ssize_t readvNoInt(int fd, const iovec* iov, int count) {
function preadvNoInt (line 114) | ssize_t preadvNoInt(int fd, const iovec* iov, int count, off_t offset) {
function writeNoInt (line 118) | ssize_t writeNoInt(int fd, const void* buf, size_t count) {
function pwriteNoInt (line 122) | ssize_t pwriteNoInt(int fd, const void* buf, size_t count, off_t offse...
function writevNoInt (line 126) | ssize_t writevNoInt(int fd, const iovec* iov, int count) {
function pwritevNoInt (line 130) | ssize_t pwritevNoInt(int fd, const iovec* iov, int count, off_t offset) {
function readFull (line 134) | ssize_t readFull(int fd, void* buf, size_t count) {
function preadFull (line 138) | ssize_t preadFull(int fd, void* buf, size_t count, off_t offset) {
function writeFull (line 142) | ssize_t writeFull(int fd, const void* buf, size_t count) {
function pwriteFull (line 146) | ssize_t pwriteFull(int fd, const void* buf, size_t count, off_t offset) {
function readvFull (line 150) | ssize_t readvFull(int fd, iovec* iov, int count) {
function preadvFull (line 154) | ssize_t preadvFull(int fd, iovec* iov, int count, off_t offset) {
function writevFull (line 158) | ssize_t writevFull(int fd, iovec* iov, int count) {
function pwritevFull (line 162) | ssize_t pwritevFull(int fd, iovec* iov, int count, off_t offset) {
function writeFileAtomicNoThrow (line 166) | int writeFileAtomicNoThrow(
function writeFileAtomic (line 232) | void writeFileAtomic(
function writeFileAtomic (line 244) | void writeFileAtomic(StringPiece filename, ByteRange data, mode_t permis...
function writeFileAtomic (line 251) | void writeFileAtomic(
FILE: example/ios/Pods/Folly/folly/FileUtil.h
function namespace (line 33) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Fingerprint.h
function namespace (line 51) | namespace folly {
function fingerprint64 (line 194) | inline uint64_t fingerprint64(StringPiece str) {
function fingerprint96 (line 205) | inline void fingerprint96(StringPiece str, uint64_t* msb, uint32_t* lsb) {
function fingerprint128 (line 217) | inline void fingerprint128(StringPiece str, uint64_t* msb, uint64_t* lsb) {
FILE: example/ios/Pods/Folly/folly/FixedString.h
function namespace (line 39) | namespace folly {
function swap (line 2967) | constexpr void swap(
function namespace (line 2973) | inline namespace literals {
FILE: example/ios/Pods/Folly/folly/Format-inl.h
function namespace (line 42) | namespace detail {
function outputString (line 175) | auto outputString = [&out](StringPiece s) {
function writer (line 285) | auto writer = [fp](StringPiece sp) {
function namespace (line 294) | namespace format_value {
type typename (line 449) | typedef typename std::make_unsigned<T>::type UT;
function namespace (line 852) | namespace detail {
function namespace (line 924) | namespace detail {
FILE: example/ios/Pods/Folly/folly/Format.cpp
type folly (line 27) | namespace folly {
type detail (line 28) | namespace detail {
type format_table_align_make_item (line 31) | struct format_table_align_make_item {
type format_table_conv_make_item (line 48) | struct format_table_conv_make_item {
type make_item (line 50) | struct make_item {
method make_item (line 52) | constexpr explicit make_item(std::size_t index_) : index(index_) {}
method alpha (line 53) | constexpr char alpha(std::size_t ord) const {
type format_table_sign_make_item (line 67) | struct format_table_sign_make_item {
function insertThousandsGroupingUnsafe (line 393) | void insertThousandsGroupingUnsafe(char* start_buffer, char** end_bu...
type detail (line 392) | namespace detail {
type format_table_align_make_item (line 31) | struct format_table_align_make_item {
type format_table_conv_make_item (line 48) | struct format_table_conv_make_item {
type make_item (line 50) | struct make_item {
method make_item (line 52) | constexpr explicit make_item(std::size_t index_) : index(index_) {}
method alpha (line 53) | constexpr char alpha(std::size_t ord) const {
type format_table_sign_make_item (line 67) | struct format_table_sign_make_item {
function insertThousandsGroupingUnsafe (line 393) | void insertThousandsGroupingUnsafe(char* start_buffer, char** end_bu...
FILE: example/ios/Pods/Folly/folly/Format.h
function class (line 51) | class FormatterTag {}
function fbstring (line 103) | fbstring fbstr() const {
function writer (line 249) | auto writer = [&out](StringPiece sp) {
function namespace (line 342) | namespace detail {
function namespace (line 386) | namespace format_value {
function namespace (line 450) | namespace detail {
FILE: example/ios/Pods/Folly/folly/FormatArg.h
function namespace (line 28) | namespace folly {
function Type (line 60) | enum class Type {
FILE: example/ios/Pods/Folly/folly/FormatTraits.h
function namespace (line 22) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Function.h
function namespace (line 233) | namespace folly {
function mutable (line 641) | mutable Data data_{}
function Call (line 642) | Call call_{&Traits::uninitCall}
function Exec (line 643) | Exec exec_{nullptr};
function swap (line 880) | void swap(Function& that) noexcept {
function SharedProxy (line 907) | SharedProxy asSharedProxy() && {
function Call (line 1021) | Call call_{&FunctionRef::uninitCall};
FILE: example/ios/Pods/Folly/folly/GroupVarint.h
function namespace (line 44) | namespace folly {
function namespace (line 51) | namespace folly {
function namespace (line 57) | namespace folly {
type GroupVarintDecoder (line 663) | typedef GroupVarintDecoder<uint32_t> GroupVarint32Decoder;
type GroupVarintDecoder (line 664) | typedef GroupVarintDecoder<uint64_t> GroupVarint64Decoder;
FILE: example/ios/Pods/Folly/folly/IPAddress.h
function namespace (line 34) | namespace folly {
function IPAddressV6 (line 277) | const IPAddressV6& asV6() const {
function bitCount (line 384) | size_t bitCount() const {
function getNthLSBit (line 398) | bool getNthLSBit(size_t bitIndex) const {
function getNthLSByte (line 402) | uint8_t getNthLSByte(size_t byteIndex) const {
function isLoopback (line 422) | bool isLoopback() const {
function isNonroutable (line 442) | bool isNonroutable() const {
function IPAddress (line 465) | IPAddress mask(uint8_t numBits) const {
function toFullyQualifiedAppend (line 488) | void toFullyQualifiedAppend(std::string& out) const {
function version (line 493) | uint8_t version() const {
function namespace (line 555) | namespace std {
FILE: example/ios/Pods/Folly/folly/IPAddressException.h
type class (line 31) | enum class
function CIDRNetworkError (line 36) | enum class CIDRNetworkError {
FILE: example/ios/Pods/Folly/folly/IPAddressV4.h
function namespace (line 32) | namespace folly {
function sockaddr_in (line 219) | sockaddr_in toSockAddr() const {
function byteCount (line 262) | static size_t byteCount() {
function getNthMSBit (line 266) | bool getNthMSBit(size_t bitIndex) const {
function getNthLSBit (line 272) | bool getNthLSBit(size_t bitIndex) const {
function getNthLSByte (line 276) | uint8_t getNthLSByte(size_t byteIndex) const {
function explicit (line 294) | explicit AddressStorage(const ByteArray4 bytes) : bytes_(bytes) {}
function explicit (line 295) | explicit AddressStorage(const in_addr addr) : inAddr_(addr) {}
function namespace (line 340) | namespace std {
FILE: example/ios/Pods/Folly/folly/IPAddressV6.h
function namespace (line 35) | namespace folly {
function scope_ (line 417) | uint16_t scope_{0};
function namespace (line 437) | namespace std {
FILE: example/ios/Pods/Folly/folly/Indestructible.h
function noexcept (line 112) | constexpr Indestructible(std::initializer_list<U> il, Args... args) noex...
function storage_ (line 123) | noexcept(
FILE: example/ios/Pods/Folly/folly/IndexedMemPool.h
function namespace (line 37) | namespace detail {
function eagerRecycle (line 47) | static constexpr bool eagerRecycle() {
function initialize (line 54) | static void initialize(T* ptr) {
function cleanup (line 62) | static void cleanup(T* ptr) {
function onRecycle (line 82) | static void onRecycle(T* ptr) {
type std (line 161) | typedef std::unique_ptr<T, detail::IndexedMemPoolRecycler<IndexedMemPool>>
function maxIndexForCapacity (line 180) | static constexpr uint32_t maxIndexForCapacity(uint32_t capacity) {
function capacityForMaxIndex (line 188) | static constexpr uint32_t capacityForMaxIndex(uint32_t maxIndex) {
function capacity (line 232) | uint32_t capacity() {
function recycleIndex (line 273) | void recycleIndex(uint32_t idx) {
function T (line 284) | const T& operator[](uint32_t idx) const {
function locateElem (line 290) | uint32_t locateElem(const T* elem) const {
function isAllocated (line 307) | bool isAllocated(uint32_t idx) const {
type Slot (line 314) | struct Slot {
function TaggedPtr (line 350) | TaggedPtr withSizeDecr() const {
function TaggedPtr (line 355) | TaggedPtr withIdx(uint32_t repl) const {
type alignas (line 364) | struct alignas
function slotIndex (line 404) | uint32_t slotIndex(uint32_t idx) const {
function Slot (line 415) | const Slot& slot(uint32_t idx) const {
function globalPush (line 421) | void globalPush(Slot& s, uint32_t localHead) {
function localPush (line 433) | void localPush(AtomicStruct<TaggedPtr, Atom>& head, uint32_t idx) {
function globalPop (line 463) | uint32_t globalPop() {
function localPop (line 478) | uint32_t localPop(AtomicStruct<TaggedPtr, Atom>& head) {
function markAllocated (line 528) | void markAllocated(Slot& slot) {
function namespace (line 536) | namespace detail {
FILE: example/ios/Pods/Folly/folly/IntrusiveList.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Lazy.h
function namespace (line 25) | namespace folly {
FILE: example/ios/Pods/Folly/folly/LockTraits.h
function namespace (line 43) | namespace member {
type class (line 57) | enum class
type MutexLevelValueImpl (line 66) | struct MutexLevelValueImpl
type MutexLevelValueImpl (line 70) | struct MutexLevelValueImpl
type MutexLevelValueImpl (line 74) | struct MutexLevelValueImpl
function is_upgrade (line 118) | static constexpr bool is_upgrade{false};
function is_upgrade (line 151) | static constexpr bool is_upgrade{false};
function is_upgrade (line 208) | static constexpr bool is_upgrade{true};
function is_timed (line 263) | static constexpr bool is_timed{true};
FILE: example/ios/Pods/Folly/folly/MPMCPipeline.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/MPMCQueue.h
function namespace (line 31) | namespace folly {
type ClosedArray (line 182) | struct ClosedArray {
function Slot (line 184) | Slot* slots_{nullptr};
function explicit (line 196) | explicit MPMCQueue(
function blockingReadWithTicket (line 321) | void blockingReadWithTicket(uint64_t& ticket, T& elem) noexcept {
function initQueue (line 349) | void initQueue(const size_t cap, const size_t mult) {
function tryObtainReadyPushTicket (line 363) | bool tryObtainReadyPushTicket(
function tryObtainPromisedPushTicket (line 409) | bool tryObtainPromisedPushTicket(
function tryObtainReadyPopTicket (line 449) | bool tryObtainReadyPopTicket(
function tryObtainPromisedPopTicket (line 480) | bool tryObtainPromisedPopTicket(
function getOffset (line 530) | uint64_t getOffset(const uint64_t state) const noexcept {
function getNumClosed (line 534) | int getNumClosed(const uint64_t state) const noexcept {
function tryExpand (line 542) | bool tryExpand(const uint64_t state, const size_t cap) noexcept {
function trySeqlockReadSection (line 587) | bool trySeqlockReadSection(
function maybeUpdateFromClosed (line 609) | bool maybeUpdateFromClosed(
function namespace (line 635) | namespace detail {
function blockingRead (line 920) | void blockingRead(T& elem) noexcept {
function blockingReadWithTicket (line 927) | void blockingReadWithTicket(uint64_t& ticket, T& elem) noexcept {
function read (line 935) | bool read(T& elem) noexcept {
function readAndGetTicket (line 941) | bool readAndGetTicket(uint64_t& ticket, T& elem) noexcept {
function readIfNotEmpty (line 979) | bool readIfNotEmpty(T& elem) noexcept {
function computeStride (line 1078) | static int computeStride(size_t capacity) noexcept {
function idx (line 1099) | size_t idx(uint64_t ticket, size_t cap, int stride) noexcept {
function turn (line 1105) | uint32_t turn(uint64_t ticket, size_t cap) noexcept {
function tryObtainReadyPushTicket (line 1113) | bool tryObtainReadyPushTicket(
function tryObtainPromisedPushTicket (line 1182) | bool tryObtainPromisedPushTicket(
function tryObtainReadyPopTicket (line 1211) | bool tryObtainReadyPopTicket(
function tryObtainPromisedPopTicket (line 1276) | bool tryObtainPromisedPopTicket(
function dequeueWithTicketBase (line 1323) | void dequeueWithTicketBase(
function dequeue (line 1409) | void dequeue(
function mayDequeue (line 1440) | bool mayDequeue(const uint32_t turn) const noexcept {
function T (line 1451) | T* ptr() noexcept {
function destroyContents (line 1455) | void destroyContents() noexcept {
type ImplByRelocation (line 1467) | struct ImplByRelocation {}
type ImplByMove (line 1468) | struct ImplByMove {}
function enqueueImpl (line 1471) | void enqueueImpl(
function enqueueImpl (line 1484) | void enqueueImpl(
function dequeueImpl (line 1501) | void dequeueImpl(
function dequeueImpl (line 1521) | void dequeueImpl(
FILE: example/ios/Pods/Folly/folly/MacAddress.h
function MacAddress (line 56) | static MacAddress fromBinary(ByteRange value) {
function MacAddress (line 71) | static MacAddress fromNBO(uint64_t value) {
function MacAddress (line 84) | static MacAddress fromHBO(uint64_t value) {
function getByte (line 213) | inline uint64_t getByte(size_t index) const {
function packedBytes (line 217) | uint64_t packedBytes() const {
FILE: example/ios/Pods/Folly/folly/MapUtil.h
function namespace (line 24) | namespace folly {
function namespace (line 185) | namespace detail {
FILE: example/ios/Pods/Folly/folly/Math.h
function namespace (line 29) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Memory.h
function namespace (line 39) | namespace folly {
type static_function_deleter (line 299) | struct static_function_deleter {
function namespace (line 351) | namespace detail {
function T (line 376) | T* allocate(size_t count) {
function deallocate (line 384) | void deallocate(T* p, size_t /* count */) {
function class (line 396) | class DefaultAlign {
function deallocate (line 503) | void deallocate(T* p, size_t /* count */) {
function explicit (line 543) | explicit CxxAllocatorAdaptor(Inner& ref) : ref_(ref) {}
function deallocate (line 553) | void deallocate(T* p, std::size_t n) {
function explicit (line 589) | explicit allocator_delete(const allocator_type& alloc)
function explicit (line 592) | explicit allocator_delete(allocator_type&& alloc)
function const (line 603) | void operator()(pointer p) const {
type DeferCondDeallocate (line 618) | struct DeferCondDeallocate {
function DeferCondDeallocate (line 632) | DeferCondDeallocate handler{constructed, copy, p};
type SysBufferDeleter (line 639) | struct SysBufferDeleter {
function SysBufferUniquePtr (line 646) | inline SysBufferUniquePtr allocate_sys_buffer(std::size_t size) {
function namespace (line 671) | namespace detail {
FILE: example/ios/Pods/Folly/folly/MicroLock.h
function namespace (line 26) | namespace folly {
type MicroLockBase (line 222) | typedef MicroLockBase<> MicroLock;
FILE: example/ios/Pods/Folly/folly/MoveWrapper.h
function explicit (line 42) | explicit MoveWrapper(T&& t) : value(std::move(t)) {}
function value (line 45) | MoveWrapper(const MoveWrapper& other) : value(std::move(other.value)) {}
FILE: example/ios/Pods/Folly/folly/Optional.h
function namespace (line 69) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Overload.h
function namespace (line 35) | namespace folly {
FILE: example/ios/Pods/Folly/folly/PackedSyncPtr.h
function namespace (line 60) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Padded.h
function namespace (line 44) | namespace folly {
function const_iterator (line 413) | const_iterator cend() const {
function iterator (line 426) | iterator begin() {
function iterator (line 429) | iterator end() {
function swap (line 436) | void swap(Adaptor& other) {
function push_back (line 479) | void push_back(value_type x) {
function pop_back (line 483) | void pop_back() {
function clear (line 491) | void clear() {
function reserve (line 496) | void reserve(size_type n) {
function value_type (line 505) | const value_type& operator[](size_type idx) const {
function padToFullNode (line 531) | void padToFullNode(const value_type& padValue) {
function Node (line 549) | static Node fullNode(const value_type& value) {
FILE: example/ios/Pods/Folly/folly/Poly-inl.h
function namespace (line 17) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Poly.h
function namespace (line 49) | namespace folly {
type NoneSuch (line 470) | struct NoneSuch {}
function noexcept (line 479) | const noexcept {
function Data (line 483) | Data* _data_() noexcept {
function Data (line 486) | Data const* _data_() const noexcept {
function Data (line 565) | Data* _data_() noexcept {
function Data (line 568) | Data const* _data_() const noexcept {
function RefType (line 572) | static constexpr RefType refType() noexcept;
FILE: example/ios/Pods/Folly/folly/PolyException.h
function namespace (line 24) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Portability.h
function namespace (line 35) | namespace folly {
function namespace (line 110) | namespace folly {
function namespace (line 117) | namespace folly {
function namespace (line 298) | namespace folly {
function namespace (line 307) | namespace folly {
function namespace (line 316) | namespace folly {
function namespace (line 365) | namespace FOLLY_GFLAGS_NAMESPACE {}
function namespace (line 366) | namespace gflags {
function namespace (line 384) | namespace folly {
function namespace (line 397) | namespace folly {
FILE: example/ios/Pods/Folly/folly/ProducerConsumerQueue.h
function namespace (line 32) | namespace folly {
function sizeGuess (line 160) | size_t sizeGuess() const {
FILE: example/ios/Pods/Folly/folly/Random-inl.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Random.h
function namespace (line 33) | namespace folly {
function randomNumberSeed (line 367) | inline uint32_t randomNumberSeed() {
FILE: example/ios/Pods/Folly/folly/Range.h
function namespace (line 113) | namespace detail {
type Iter (line 154) | typedef Iter iterator;
type Iter (line 155) | typedef Iter const_iterator;
type typename (line 156) | typedef typename std::remove_reference<
type typename (line 159) | typedef typename std::iterator_traits<Iter>::reference reference;
type typename (line 167) | typedef typename std::conditional<
type std (line 173) | typedef std::char_traits<typename
function Range (line 238) | Range(const Range& other, size_type first, size_type length = npos)
function clear (line 400) | void clear() {
function assign (line 405) | void assign(Iter start, Iter end) {
function reset (line 410) | void reset(Iter start, size_type size) {
function size_type (line 427) | constexpr size_type walk_size() const {
function value_type (line 459) | const value_type& front() const {
type NotStringView (line 486) | struct NotStringView {}
function explicit (line 521) | explicit operator Tgt() const noexcept(
function value_type (line 622) | const value_type& operator[](size_t i) const {
function value_type (line 634) | const value_type& at(size_t i) const {
function hash (line 659) | [[deprecated(
function advance (line 671) | void advance(size_type n) {
function subtract (line 678) | void subtract(size_type n) {
function Range (line 685) | Range subpiece(size_type first, size_type length = npos) const {
function uncheckedAdvance (line 694) | void uncheckedAdvance(size_type n) {
function uncheckedSubtract (line 699) | void uncheckedSubtract(size_type n) {
function Range (line 704) | Range uncheckedSubpiece(size_type first, size_type length = npos) const {
function pop_front (line 709) | void pop_front() {
function pop_back (line 714) | void pop_back() {
function size_type (line 720) | size_type find(const_range_type str) const {
function size_type (line 724) | size_type find(const_range_type str, size_t pos) const {
function size_type (line 732) | size_type find(Iter s, size_t pos, size_t n) const {
function size_type (line 743) | size_type find(const Iter s) const {
function size_type (line 748) | size_type find(const Iter s, size_t pos) const {
function size_type (line 756) | size_type find(value_type c) const {
function size_type (line 760) | size_type rfind(value_type c) const {
function size_type (line 764) | size_type find(value_type c, size_t pos) const {
function size_type (line 772) | size_type find_first_of(const_range_type needles) const {
function size_type (line 776) | size_type find_first_of(const_range_type needles, size_t pos) const {
function size_type (line 785) | size_type find_first_of(Iter needles) const {
function size_type (line 790) | size_type find_first_of(Iter needles, size_t pos) const {
function size_type (line 794) | size_type find_first_of(Iter needles, size_t pos, size_t n) const {
function size_type (line 798) | size_type find_first_of(value_type c) const {
function size_type (line 802) | size_type find_first_of(value_type c, size_t pos) const {
function contains (line 811) | bool contains(const const_range_type& other) const {
function contains (line 815) | bool contains(const value_type& other) const {
function swap (line 819) | void swap(Range& rhs) {
function startsWith (line 827) | bool startsWith(const const_range_type& other) const {
function startsWith (line 831) | bool startsWith(value_type c) const {
function endsWith (line 848) | bool endsWith(const const_range_type& other) const {
function endsWith (line 852) | bool endsWith(value_type c) const {
function erase (line 878) | void erase(Iter b, Iter e) {
function removePrefix (line 892) | bool removePrefix(const const_range_type& prefix) {
function removePrefix (line 895) | bool removePrefix(value_type prefix) {
function removeSuffix (line 903) | bool removeSuffix(const const_range_type& suffix) {
function removeSuffix (line 906) | bool removeSuffix(value_type suffix) {
function replaceAt (line 924) | bool replaceAt(size_t pos, const_range_type replacement) {
function replaceAll (line 948) | size_t replaceAll(const_range_type source, const_range_type dest) {
function Range (line 1000) | Range split_step(value_type delimiter) {
function Range (line 1009) | Range split_step(Range delimiter) {
type Range (line 1161) | typedef Range<char*> MutableStringPiece;
type Range (line 1162) | typedef Range<const unsigned
type MutableByteRange (line 1163) | typedef Range<unsigned char*> MutableByteRange;
function namespace (line 1219) | namespace detail {
function namespace (line 1352) | namespace detail {
function qfind (line 1445) | inline size_t qfind(
function rfind (line 1458) | inline size_t rfind(
function qfind_first_of (line 1477) | inline size_t qfind_first_of(
function qfind_first_of (line 1485) | inline size_t qfind_first_of(
function const (line 1501) | size_t operator()(folly::Range<T*> r) const {
function namespace (line 1518) | inline namespace literals {
FILE: example/ios/Pods/Folly/folly/Replaceable.h
function namespace (line 123) | namespace folly {
function explicit (line 195) | inline explicit default_and_move_ctor_mixin(int) {}
function noexcept (line 205) | inline default_and_move_ctor_mixin(
function explicit (line 236) | inline explicit default_and_move_ctor_mixin(int) {}
function noexcept (line 243) | inline default_and_move_ctor_mixin(
function explicit (line 256) | inline explicit default_and_move_ctor_mixin(int) {}
function noexcept (line 312) | inline copy_ctor_mixin(copy_ctor_mixin const& other) noexcept(
function explicit (line 451) | explicit Replaceable(
function swap (line 594) | void swap(Replaceable& other) noexcept(IsNothrowSwappable<Replaceable>{}) {
function T (line 602) | constexpr const T* operator->() const {
function T (line 606) | constexpr T* operator->() {
type replaceable_detail (line 627) | struct replaceable_detail
FILE: example/ios/Pods/Folly/folly/ScopeGuard.h
function namespace (line 32) | namespace folly {
function namespace (line 187) | namespace detail {
FILE: example/ios/Pods/Folly/folly/SharedMutex.h
function namespace (line 248) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Singleton-inl.h
function namespace (line 17) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Singleton.h
function namespace (line 160) | namespace folly {
function explicit (line 716) | explicit LeakySingleton(CreateFunc createFunc) {
function T (line 725) | static T& get() {
function make_mock (line 733) | static void make_mock(CreateFunc createFunc) {
type class (line 747) | enum class
type Entry (line 749) | struct Entry {
function T (line 755) | T* ptr{nullptr};
FILE: example/ios/Pods/Folly/folly/SingletonThreadLocal.h
function namespace (line 38) | namespace folly {
FILE: example/ios/Pods/Folly/folly/SocketAddress.h
function namespace (line 32) | namespace folly {
function isPrivateAddress (line 150) | bool isPrivateAddress() const;
function setFromIpPort (line 199) | void setFromIpPort(const std::string& ip, uint16_t port) {
function setFromLocalPort (line 232) | void setFromLocalPort(const std::string& port) {
function setFromLocalIpPort (line 249) | void setFromLocalIpPort(const std::string& addressAndPort) {
function setFromIpPort (line 263) | void setFromIpPort(const std::string& addressAndPort) {
function setFromHostPort (line 278) | void setFromHostPort(const std::string& hostAndPort) {
type sockaddr (line 289) | struct sockaddr
type sockaddr (line 298) | struct sockaddr
function setFromPath (line 308) | void setFromPath(const char* path, size_t length) {
function init (line 568) | void init(const ExternalUnixAddr& other) {
function copy (line 573) | void copy(const ExternalUnixAddr& other) {
function free (line 577) | void free() {
type addrinfo (line 582) | struct addrinfo
type addrinfo (line 583) | struct addrinfo
type addrinfo (line 584) | struct addrinfo
type addrinfo (line 585) | struct addrinfo
type sockaddr (line 588) | struct sockaddr
function namespace (line 623) | namespace std {
FILE: example/ios/Pods/Folly/folly/SpinLock.h
function namespace (line 40) | namespace folly {
FILE: example/ios/Pods/Folly/folly/String-inl.h
function namespace (line 28) | namespace folly {
function namespace (line 156) | namespace detail {
function namespace (line 246) | namespace detail {
function prepareDelim (line 334) | inline char prepareDelim(char c) {
function toOrIgnore (line 343) | inline void toOrIgnore(StringPiece, decltype(std::ignore)&) {}
function namespace (line 434) | namespace detail {
function namespace (line 638) | namespace detail {
FILE: example/ios/Pods/Folly/folly/String.cpp
type folly (line 33) | namespace folly {
type detail (line 41) | namespace detail {
type string_table_c_escape_make_item (line 43) | struct string_table_c_escape_make_item {
type string_table_c_unescape_make_item (line 59) | struct string_table_c_unescape_make_item {
type string_table_hex_make_item (line 81) | struct string_table_hex_make_item {
type string_table_uri_escape_make_item (line 93) | struct string_table_uri_escape_make_item {
function hexDumpLine (line 677) | size_t
function is_oddspace (line 127) | static inline bool is_oddspace(char c) {
function StringPiece (line 131) | StringPiece ltrimWhitespace(StringPiece sp) {
function StringPiece (line 149) | StringPiece rtrimWhitespace(StringPiece sp) {
function stringAppendfImplHelper (line 169) | int stringAppendfImplHelper(
function stringAppendfImpl (line 181) | void stringAppendfImpl(std::string& output, const char* format, va_lis...
function stringPrintf (line 223) | std::string stringPrintf(const char* format, ...) {
function stringVPrintf (line 232) | std::string stringVPrintf(const char* format, va_list ap) {
function stringPrintf (line 255) | void stringPrintf(std::string* output, const char* format, ...) {
function stringVPrintf (line 264) | void stringVPrintf(std::string* output, const char* format, va_list ap) {
type PrettySuffix (line 271) | struct PrettySuffix {
function prettyPrint (line 386) | std::string prettyPrint(double val, PrettyType type, bool addSpace) {
function prettyToDouble (line 416) | double prettyToDouble(
function prettyToDouble (line 451) | double prettyToDouble(folly::StringPiece prettyString, const PrettyTyp...
function hexDump (line 457) | std::string hexDump(const void* ptr, size_t size) {
function FOLLY_MAYBE_UNUSED (line 474) | FOLLY_MAYBE_UNUSED
function FOLLY_MAYBE_UNUSED (line 492) | FOLLY_MAYBE_UNUSED
function fbstring (line 502) | fbstring errnoStr(int err) {
function toLowerAscii8 (line 536) | void toLowerAscii8(char& c) {
function toLowerAscii32 (line 594) | void toLowerAscii32(uint32_t& c) {
function toLowerAscii64 (line 614) | void toLowerAscii64(uint64_t& c) {
function toLowerAscii (line 628) | void toLowerAscii(char* str, size_t length) {
type detail (line 675) | namespace detail {
type string_table_c_escape_make_item (line 43) | struct string_table_c_escape_make_item {
type string_table_c_unescape_make_item (line 59) | struct string_table_c_unescape_make_item {
type string_table_hex_make_item (line 81) | struct string_table_hex_make_item {
type string_table_uri_escape_make_item (line 93) | struct string_table_uri_escape_make_item {
function hexDumpLine (line 677) | size_t
function stripLeftMargin (line 731) | std::string stripLeftMargin(std::string s) {
FILE: example/ios/Pods/Folly/folly/String.h
function namespace (line 38) | namespace folly {
function toLowerAscii (line 638) | inline void toLowerAscii(MutableStringPiece str) {
function toLowerAscii (line 642) | inline void toLowerAscii(std::string& str) {
FILE: example/ios/Pods/Folly/folly/Subprocess.h
type State (line 128) | enum State {
function ProcessReturnCode (line 137) | static ProcessReturnCode makeNotStarted() {
function ProcessReturnCode (line 141) | static ProcessReturnCode makeRunning() {
function rawStatus_ (line 149) | rawStatus_(RV_NOT_STARTED) {}
function State (line 166) | State state() const;
type DangerousPostForkPreExecCallback (line 284) | struct DangerousPostForkPreExecCallback {
function usePath_ (line 493) | bool usePath_{false};
FILE: example/ios/Pods/Folly/folly/Synchronized.h
function LockedPtr (line 114) | LockedPtr wlock() {
function TryWLockedPtr (line 128) | TryWLockedPtr tryWLock() {
function UpgradeLockedPtr (line 282) | UpgradeLockedPtr ulock() {
function TryUpgradeLockedPtr (line 296) | TryUpgradeLockedPtr tryULock() {
function LockedPtr (line 383) | LockedPtr lock() {
function TryLockedPtr (line 402) | TryLockedPtr tryLock() {
function nxMoveCtor (line 497) | static constexpr bool nxMoveCtor{
function guard (line 623) | auto guard = LockedPtr{this};
function guard (line 634) | auto guard = LockedPtr{this};
function LockedPtr (line 652) | LockedPtr contextualLock() {
function LockedPtr (line 692) | [[deprecated("use explicit lock(), wlock(), or rlock() instead")]] Locke...
function ConstLockedPtr (line 703) | [[deprecated(
function LockedPtr (line 717) | LockedPtr timedAcquire(unsigned int milliseconds) {
function ConstLockedPtr (line 729) | ConstLockedPtr timedAcquire(unsigned int milliseconds) const {
function guard1 (line 745) | auto guard1 = LockedPtr{this};
function unlock (line 1087) | void unlock() {
function explicit (line 1095) | explicit LockedPtrBase(SynchronizedType* parent) : parent_(parent) {
function SynchronizedType (line 1162) | static SynchronizedType* getSynchronized(UnlockerData data) {
function UnlockerData (line 1166) | UnlockerData releaseLock() {
function reacquireLock (line 1173) | void reacquireLock(UnlockerData&& data) {
function unlock (line 1272) | void unlock() {
function explicit (line 1280) | explicit LockedPtrBase(SynchronizedType* parent)
function SynchronizedType (line 1339) | SynchronizedType* getSynchronized() const {
function explicit (line 1402) | explicit LockedPtr(SynchronizedType* parent) : Base(parent) {}
function locker (line 1701) | auto locker = [](auto& lockable) {
FILE: example/ios/Pods/Folly/folly/SynchronizedPtr.h
function namespace (line 33) | namespace folly {
FILE: example/ios/Pods/Folly/folly/ThreadCachedInt.h
function namespace (line 30) | namespace folly {
FILE: example/ios/Pods/Folly/folly/ThreadLocal.h
function namespace (line 54) | namespace folly {
function T (line 158) | T* get() const {
function guard (line 182) | auto guard = makeGuard([&] { delete newPtr; }
function guard (line 236) | auto guard = makeGuard([&] {
function class (line 254) | class Accessor {
function release (line 438) | void release() {
function namespace (line 478) | namespace threadlocal_detail {
FILE: example/ios/Pods/Folly/folly/TimeoutQueue.h
function namespace (line 38) | namespace folly {
FILE: example/ios/Pods/Folly/folly/TokenBucket.h
function namespace (line 28) | namespace folly {
function defaultClockNow (line 375) | static double defaultClockNow() noexcept(noexcept(Impl::defaultClockNow(...
function setCapacity (line 412) | void setCapacity(double tokens, double nowInSeconds) noexcept {
function consume (line 430) | bool consume(double toConsume, double nowInSeconds = defaultClockNow()) {
function consumeOrDrain (line 447) | double consumeOrDrain(
function returnTokens (line 457) | void returnTokens(double tokensToReturn) {
function consumeWithBorrowAndWait (line 475) | bool consumeWithBorrowAndWait(
function available (line 487) | double available(double nowInSeconds = defaultClockNow()) const {
FILE: example/ios/Pods/Folly/folly/Traits.h
function namespace (line 125) | namespace folly {
function namespace (line 350) | namespace traits_detail {
function namespace (line 421) | namespace traits_detail {
type Ignore (line 440) | struct Ignore {
function namespace (line 453) | namespace traits_detail_IsEqualityComparable {
function namespace (line 466) | namespace traits_detail_IsLessThanComparable {
function namespace (line 479) | namespace traits_detail_IsNothrowSwappable {
function size (line 567) | static constexpr std::size_t size() {
function namespace (line 582) | namespace detail {
function namespace (line 670) | namespace folly {
function FOLLY_NAMESPACE_STD_BEGIN (line 782) | FOLLY_NAMESPACE_STD_BEGIN
type is_arithmetic (line 786) | struct is_arithmetic
function true_type (line 788) | struct is_integral<__int128> : ::std::true_type {}
type is_integral (line 790) | struct is_integral
function __int128 (line 792) | struct make_unsigned<__int128> {
function __int128 (line 796) | struct make_signed<__int128> {
type make_unsigned (line 800) | struct make_unsigned
type type (line 801) | typedef unsigned __int128 type;
type make_signed (line 804) | struct make_signed
type __int128 (line 805) | typedef __int128 type;
function true_type (line 808) | struct is_signed<__int128> : ::std::true_type {}
type is_unsigned (line 810) | struct is_unsigned
function namespace (line 814) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Try-inl.h
function namespace (line 26) | namespace folly {
function makeTryWithNoUnwrap (line 238) | void>>::type
function namespace (line 322) | namespace try_detail {
FILE: example/ios/Pods/Folly/folly/Try.h
function namespace (line 32) | namespace folly {
function explicit (line 399) | explicit Try(exception_wrapper e) noexcept
function emplace (line 424) | void emplace() noexcept {
function throwIfFailed (line 457) | inline void throwIfFailed() const;
function exception_wrapper (line 493) | const exception_wrapper& exception() const& {
function exception_wrapper (line 500) | const exception_wrapper&& exception() const&& {
FILE: example/ios/Pods/Folly/folly/UTF8String.h
function namespace (line 25) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Unicode.cpp
type folly (line 20) | namespace folly {
function codePointToUtf8 (line 24) | std::string codePointToUtf8(char32_t cp) {
function utf8ToCodePoint (line 52) | char32_t utf8ToCodePoint(
FILE: example/ios/Pods/Folly/folly/Unicode.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Unit.h
function namespace (line 21) | namespace folly {
function Unit (line 45) | constexpr Unit unit{}
function void (line 52) | struct lift_unit<void> {
function Unit (line 63) | struct drop_unit<Unit> {
FILE: example/ios/Pods/Folly/folly/Uri-inl.h
function namespace (line 27) | namespace folly {
function namespace (line 84) | namespace std {
function Uri (line 95) | struct equal_to<folly::Uri> {
FILE: example/ios/Pods/Folly/folly/Uri.h
function namespace (line 25) | namespace folly {
FILE: example/ios/Pods/Folly/folly/Utility.h
function namespace (line 28) | namespace folly {
type initlist_construct_t (line 188) | struct initlist_construct_t {}
function initlist_construct_t (line 189) | constexpr initlist_construct_t initlist_construct{}
type sorted_unique_t (line 212) | struct sorted_unique_t {}
type sorted_equivalent_t (line 235) | struct sorted_equivalent_t {}
type Identity (line 263) | struct Identity {
function namespace (line 270) | namespace moveonly_ { // Protection from unintended ADL.
function explicit (line 313) | explicit constexpr to_narrow_convertible(Src const& value) noexcept
FILE: example/ios/Pods/Folly/folly/Varint.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/VirtualExecutor.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/Access.h
function namespace (line 31) | namespace folly {
function namespace (line 41) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/Array.h
function namespace (line 27) | namespace folly {
function namespace (line 61) | namespace array_detail {
FILE: example/ios/Pods/Folly/folly/container/BitIterator.h
function namespace (line 45) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/Enumerate.h
function namespace (line 47) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/EvictingCacheMap.h
function namespace (line 30) | namespace folly {
function setClearSize (line 218) | void setClearSize(size_t clearSize) {
function exists (line 228) | bool exists(const TKey& key) const {
function iterator (line 254) | iterator find(const TKey& key) {
function TValue (line 271) | const TValue& getWithoutPromotion(const TKey& key) const {
function const_iterator (line 291) | const_iterator findWithoutPromotion(const TKey& key) const {
function iterator (line 296) | iterator findWithoutPromotion(const TKey& key) {
function erase (line 306) | bool erase(const TKey& key) {
function iterator (line 321) | iterator erase(const_iterator pos) {
function setPruneHook (line 417) | void setPruneHook(PruneHookCall pruneHook) {
function iterator (line 433) | iterator begin() {
function iterator (line 436) | iterator end() {
function reverse_iterator (line 453) | reverse_iterator rbegin() {
function reverse_iterator (line 456) | reverse_iterator rend() {
type Node (line 475) | struct Node
function const (line 482) | struct KeyHasher {
function const (line 493) | struct KeyValueEqual {
function const (line 501) | bool operator()(const Node& lhs, const Node& rhs) const {
function typename (line 514) | typename NodeMap::iterator findInIndex(const TKey& key) {
function typename (line 518) | typename NodeMap::const_iterator findInIndex(const TKey& key) const {
function pruneWithFailSafeOption (line 528) | void pruneWithFailSafeOption(
FILE: example/ios/Pods/Folly/folly/container/F14Map-fwd.h
function namespace (line 24) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/F14Map.h
function namespace (line 46) | namespace folly {
function table_ (line 167) | noexcept(
function iterator (line 214) | iterator begin() noexcept {
function const_iterator (line 217) | const_iterator begin() const noexcept {
function iterator (line 224) | iterator end() noexcept {
function const_iterator (line 227) | const_iterator end() const noexcept {
function clear (line 250) | void clear() noexcept {
function iterator (line 296) | iterator insert(const_iterator /*hint*/, value_type const& value) {
function iterator (line 306) | iterator insert(const_iterator /*hint*/, value_type&& value) {
function bulkInsert (line 317) | void
function insert (line 363) | void insert(std::initializer_list<value_type> ilist) {
function FOLLY_ALWAYS_INLINE (line 479) | FOLLY_ALWAYS_INLINE iterator erase(const_iterator pos) {
function FOLLY_ALWAYS_INLINE (line 490) | FOLLY_ALWAYS_INLINE iterator erase(iterator pos) {
function iterator (line 497) | iterator erase(const_iterator first, const_iterator last) {
function size_type (line 507) | size_type erase(key_type const& key) {
function FOLLY_ALWAYS_INLINE (line 518) | FOLLY_ALWAYS_INLINE mapped_type& at(key_type const& key) {
function FOLLY_ALWAYS_INLINE (line 522) | FOLLY_ALWAYS_INLINE mapped_type const& at(key_type const& key) const {
function FOLLY_ALWAYS_INLINE (line 549) | FOLLY_ALWAYS_INLINE size_type count(key_type const& key) const {
function F14HashToken (line 573) | F14HashToken prehash(key_type const& key) const {
function FOLLY_ALWAYS_INLINE (line 582) | FOLLY_ALWAYS_INLINE iterator find(key_type const& key) {
function FOLLY_ALWAYS_INLINE (line 590) | FOLLY_ALWAYS_INLINE iterator
function FOLLY_ALWAYS_INLINE (line 625) | FOLLY_ALWAYS_INLINE bool contains(key_type const& key) const {
function FOLLY_ALWAYS_INLINE (line 635) | FOLLY_ALWAYS_INLINE bool contains(
function max_load_factor (line 689) | void max_load_factor(float v) {
function rehash (line 693) | void rehash(std::size_t bucketCapacity) {
function reserve (line 700) | void reserve(std::size_t capacity) {
function containsEqualValue (line 721) | bool containsEqualValue(value_type const& value) const {
function swap (line 821) | void swap(F14ValueMap& rhs) noexcept(Policy::kSwapIsNoexcept) {
function swap (line 869) | void swap(F14NodeMap& rhs) noexcept(Policy::kSwapIsNoexcept) {
function namespace (line 884) | namespace f14 {
function swap (line 1077) | void swap(F14VectorMap& rhs) noexcept(Super::Policy::kSwapIsNoexcept) {
function reverse_iterator (line 1107) | reverse_iterator rbegin() {
function reverse_iterator (line 1117) | reverse_iterator rend() {
function iterator (line 1128) | iterator iter(reverse_iterator riter) {
function const_iterator (line 1131) | const_iterator iter(const_reverse_iterator riter) const {
function reverse_iterator (line 1135) | reverse_iterator riter(iterator it) {
function const_reverse_iterator (line 1138) | const_reverse_iterator riter(const_iterator it) const {
function swap (line 1188) | void swap(F14FastMap& rhs) noexcept(Super::Policy::kSwapIsNoexcept) {
function namespace (line 1201) | namespace folly {
function namespace (line 1355) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/F14Set-fwd.h
function namespace (line 22) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/F14Set.h
function namespace (line 43) | namespace folly {
function table_ (line 162) | noexcept(
function iterator (line 209) | iterator begin() noexcept {
function const_iterator (line 212) | const_iterator begin() const noexcept {
function iterator (line 219) | iterator end() noexcept {
function const_iterator (line 222) | const_iterator end() const noexcept {
function clear (line 245) | void clear() noexcept {
function iterator (line 262) | iterator insert(const_iterator /*hint*/, value_type const& value) {
function iterator (line 266) | iterator insert(const_iterator /*hint*/, value_type&& value) {
function bulkInsert (line 277) | void
function insert (line 323) | void insert(std::initializer_list<value_type> ilist) {
function FOLLY_ALWAYS_INLINE (line 350) | FOLLY_ALWAYS_INLINE iterator erase(const_iterator pos) {
function iterator (line 354) | iterator erase(const_iterator first, const_iterator last) {
function size_type (line 358) | size_type erase(key_type const& key) {
function iterator (line 372) | iterator
function FOLLY_ALWAYS_INLINE (line 408) | FOLLY_ALWAYS_INLINE size_type count(key_type const& key) const {
function F14HashToken (line 432) | F14HashToken prehash(key_type const& key) const {
function FOLLY_ALWAYS_INLINE (line 441) | FOLLY_ALWAYS_INLINE iterator find(key_type const& key) {
function FOLLY_ALWAYS_INLINE (line 449) | FOLLY_ALWAYS_INLINE iterator
function FOLLY_ALWAYS_INLINE (line 484) | FOLLY_ALWAYS_INLINE bool contains(key_type const& key) const {
function FOLLY_ALWAYS_INLINE (line 494) | FOLLY_ALWAYS_INLINE bool contains(
function max_load_factor (line 548) | void max_load_factor(float v) {
function rehash (line 552) | void rehash(std::size_t bucketCapacity) {
function reserve (line 559) | void reserve(std::size_t capacity) {
function containsEqualValue (line 581) | bool containsEqualValue(value_type const& value) const {
function swap (line 664) | void swap(F14ValueSet& rhs) noexcept(Policy::kSwapIsNoexcept) {
function swap (line 705) | void swap(F14NodeSet& rhs) noexcept(Policy::kSwapIsNoexcept) {
function namespace (line 718) | namespace f14 {
function iterator (line 832) | iterator erase(const_iterator first, const_iterator last) {
function iterator (line 846) | iterator
function swap (line 912) | void swap(F14VectorSet& rhs) noexcept(Super::Policy::kSwapIsNoexcept) {
function reverse_iterator (line 942) | reverse_iterator rbegin() {
function reverse_iterator (line 952) | reverse_iterator rend() {
function iterator (line 963) | iterator iter(reverse_iterator riter) {
function const_iterator (line 966) | const_iterator iter(const_reverse_iterator riter) const {
function reverse_iterator (line 970) | reverse_iterator riter(iterator it) {
function const_reverse_iterator (line 973) | const_reverse_iterator riter(const_iterator it) const {
function swap (line 1009) | void swap(F14FastSet& rhs) noexcept(Super::Policy::kSwapIsNoexcept) {
function namespace (line 1021) | namespace folly {
function namespace (line 1156) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/Foreach-inl.h
function namespace (line 30) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/Foreach.h
function namespace (line 24) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/HeterogeneousAccess-fwd.h
function namespace (line 19) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/HeterogeneousAccess.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/Iterator.h
function namespace (line 29) | namespace folly {
function namespace (line 97) | namespace detail {
function namespace (line 152) | namespace detail {
function iter (line 175) | container(std::addressof(c)), iter(std::move(i)) {}
function explicit (line 190) | explicit EmplaceFront(Container& c) : container(std::addressof(c)) {}
function explicit (line 203) | explicit EmplaceBack(Container& c) : container(std::addressof(c)) {}
FILE: example/ios/Pods/Folly/folly/container/Merge.h
function namespace (line 43) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/SparseByteSet.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/detail/BitIteratorDetail.h
function namespace (line 24) | namespace folly {
type boost (line 79) | typedef boost::iterator_adaptor<
FILE: example/ios/Pods/Folly/folly/container/detail/F14Defaults.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/detail/F14IntrinsicsAvailability.h
function namespace (line 47) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/detail/F14Mask.h
function namespace (line 31) | namespace folly {
FILE: example/ios/Pods/Folly/folly/container/detail/F14Policy.h
function isAvalanchingHasher (line 171) | static constexpr bool isAvalanchingHasher() {
function swapBasePolicy (line 261) | void swapBasePolicy(BasePolicy& rhs) {
function computeKeyHash (line 289) | size_t computeKeyHash(K const& key) const {
function Key (line 299) | Key const& keyForValue(Key const& v) const {
function Key (line 302) | Key const& keyForValue(std::pair<Key const, MappedOrBool> const& p) const {
function Key (line 305) | Key const& keyForValue(std::pair<Key&&, MappedOrBool&&> const& p) const {
function operator (line 460) | operator ValueContainerIterator<ValueConstPtr>() const {
function reference (line 464) | reference operator*() const {
function pointer (line 468) | pointer operator->() const {
function rhs (line 483) | bool operator==(ValueContainerIterator<ValueConstPtr> const& rhs) const {
function rhs (line 486) | bool operator!=(ValueContainerIterator<ValueConstPtr> const& rhs) const {
function explicit (line 493) | explicit ValueContainerIterator(ItemIter const& underlying)
function prefetchBeforeRehash (line 544) | static constexpr bool prefetchBeforeRehash() {
function prefetchBeforeCopy (line 548) | static constexpr bool prefetchBeforeCopy() {
function prefetchBeforeDestroy (line 552) | static constexpr bool prefetchBeforeDestroy() {
function destroyItemOnClear (line 556) | static constexpr bool destroyItemOnClear() {
function swapPolicy (line 564) | void swapPolicy(ValueContainerPolicy& rhs) {
function Value (line 582) | Value const& buildArgForItem(Item const& item) const& {
function buildArgForItem (line 587) | decltype(auto) buildArgForItem(Item& item) && {
function Value (line 591) | Value const& valueAtItem(Item const& item) const {
function moveItemDuringRehash (line 623) | void moveItemDuringRehash(Item* itemAddr, Item& src) {
function destroyItem (line 643) | void destroyItem(Item& item) {
function ConstIter (line 669) | ConstIter makeConstIter(ItemIter const& underlying) const {
function operator (line 705) | operator NodeContainerIterator<ValueConstPtr>() const {
function reference (line 709) | reference operator*() const {
function pointer (line 713) | pointer operator->() const {
function rhs (line 728) | bool operator==(NodeContainerIterator<ValueConstPtr> const& rhs) const {
function rhs (line 731) | bool operator!=(NodeContainerIterator<ValueConstPtr> const& rhs) const {
function explicit (line 738) | explicit NodeContainerIterator(ItemIter const& underlying)
function prefetchBeforeRehash (line 800) | static constexpr bool prefetchBeforeRehash() {
function prefetchBeforeCopy (line 804) | static constexpr bool prefetchBeforeCopy() {
function prefetchBeforeDestroy (line 808) | static constexpr bool prefetchBeforeDestroy() {
function destroyItemOnClear (line 812) | static constexpr bool destroyItemOnClear() {
function swapPolicy (line 819) | void swapPolicy(NodeContainerPolicy& rhs) {
function Value (line 834) | Value const& buildArgForItem(Item const& item) const& {
function buildArgForItem (line 839) | decltype(auto) buildArgForItem(Item& item) && {
function Value (line 843) | Value const& valueAtItem(Item const& item) const {
function Item (line 856) | new (itemAddr) Item{AllocTraits::allocate(a, 1)};
function moveItemDuringRehash (line 865) | void moveItemDuringRehash(Item* itemAddr, Item& src) {
function moveItemDuringRehash (line 1247) | void moveItemDuringRehash(Item* itemAddr, Item& src) {
function prefetchValue (line 1251) | void prefetchValue(Item const& item) const {
function destroyItem (line 1255) | void destroyItem(Item&) {}
function transfer (line 1267) | void transfer(Alloc& a, Value* src, Value* dst, std::size_t n) {
function beforeBuild (line 1324) | bool beforeBuild(
function beforeBuild (line 1331) | bool beforeBuild(
function allocSize (line 1367) | static std::size_t allocSize(
function Iter (line 1483) | Iter linearEnd() const {
function ConstIter (line 1499) | ConstIter makeConstIter(ItemIter const& underlying) const {
function Item (line 1503) | Item iterToIndex(ConstIter const& iter) const {
function Iter (line 1509) | Iter indexToIter(Item index) const {
FILE: example/ios/Pods/Folly/folly/container/detail/F14Table.cpp
type folly (line 22) | namespace folly {
type f14 (line 23) | namespace f14 {
type detail (line 24) | namespace detail {
function tlsPendingSafeInserts (line 45) | bool tlsPendingSafeInserts(std::ptrdiff_t delta) {
function tlsMinstdRand (line 58) | std::size_t tlsMinstdRand(std::size_t n) {
FILE: example/ios/Pods/Folly/folly/container/detail/F14Table.h
function namespace (line 90) | namespace folly {
function chunkAllocSize (line 1214) | static std::size_t chunkAllocSize(
function ChunkPtr (line 1227) | ChunkPtr initializeChunks(
function max_load_factor (line 1291) | void max_load_factor(float) noexcept {
function ItemIter (line 1394) | ItemIter find(K const& key) const {
function ItemIter (line 1400) | ItemIter
function ItemIter (line 1413) | ItemIter findMatching(K const& key, F&& func) const {
function ItemIter (line 1499) | ItemIter allocateTag(uint8_t* fullness, HashPair hp) {
function ByteAlloc (line 1635) | ByteAlloc a{this->alloc()};
function ByteAlloc (line 1640) | ByteAlloc a{this->alloc()};
function HashPair (line 1688) | HashPair hp{srcChunkIndex, srcChunk->tag(i)};
function reserveImpl (line 1750) | void reserveImpl(std::size_t desiredCapacity) {
function FOLLY_NOINLINE (line 1791) | FOLLY_NOINLINE void reserveForInsertImpl(
function rehashImpl (line 1823) | void rehashImpl(
function HashPair (line 2359) | HashPair hp{ci, tag};
function namespace (line 2396) | namespace f14 {
FILE: example/ios/Pods/Folly/folly/container/detail/Util.h
function namespace (line 29) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/AsyncTrace.h
function namespace (line 20) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/AtFork.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/AtomicHashUtils.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/AtomicUnorderedMapUtils.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/Demangle.cpp
type folly (line 29) | namespace folly {
type detail (line 30) | namespace detail {
function cplus_demangle_v3_callback_wrapper (line 32) | int cplus_demangle_v3_callback_wrapper(
FILE: example/ios/Pods/Folly/folly/detail/Demangle.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/DiscriminatedPtrDetail.h
function namespace (line 24) | namespace folly {
type IsSameType (line 57) | struct IsSameType<> {
type T (line 79) | typedef T type;
type invoke_result_t (line 89) | typedef invoke_result_t<V, T*> type;
type invoke_result_t (line 96) | typedef invoke_result_t<V, const
type typename (line 104) | typedef
type typename (line 113) | typedef
function R (line 123) | R operator()(size_t, V&& visitor, void* ptr) const {
function R (line 130) | R operator()(size_t runtimeIndex, V&& visitor, void* ptr) const {
function R (line 143) | R operator()(size_t, V&& visitor, void* ptr) const {
function R (line 150) | R operator()(size_t runtimeIndex, V&& visitor, void* ptr) const {
FILE: example/ios/Pods/Folly/folly/detail/FileUtilDetail.h
function namespace (line 29) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/FingerprintPolynomial.h
function namespace (line 22) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/Futex-inl.h
function namespace (line 22) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/Futex.h
function namespace (line 28) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/GroupVarintDetail.h
function uint32_t (line 33) | struct GroupVarintTraits<uint32_t> {
FILE: example/ios/Pods/Folly/folly/detail/IPAddress.h
function namespace (line 25) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/IPAddressSource.h
function namespace (line 38) | namespace folly {
function writeIntegerString (line 185) | void writeIntegerString(IntegralType val, char** buffer) {
function fastIpV4ToBufferUnsafe (line 219) | inline size_t fastIpV4ToBufferUnsafe(const in_addr& inAddr, char* str) {
function std (line 234) | inline std::string fastIpv4ToString(const in_addr& inAddr) {
function fastIpv4AppendToString (line 239) | inline void fastIpv4AppendToString(const in_addr& inAddr, std::string& o...
function fastIpv6ToBufferUnsafe (line 244) | inline size_t fastIpv6ToBufferUnsafe(const in6_addr& in6Addr, char* str) {
function std (line 267) | inline std::string fastIpv6ToString(const in6_addr& in6Addr) {
function fastIpv6AppendToString (line 272) | inline void fastIpv6AppendToString(const in6_addr& in6Addr, std::string&...
FILE: example/ios/Pods/Folly/folly/detail/Iterators.h
function namespace (line 49) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/MPMCPipelineDetail.h
function namespace (line 21) | namespace folly {
function blockingRead (line 82) | uint64_t blockingRead(T& elem) noexcept {
function read (line 88) | bool read(T& elem) noexcept { // only use on last stage, won't track ticket
function tuple (line 115) | struct AmplificationProduct<std::tuple<>> {
FILE: example/ios/Pods/Folly/folly/detail/MemoryIdler.h
function namespace (line 28) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/PolyDetail.h
function namespace (line 43) | namespace folly {
type PolyBase (line 292) | struct PolyBase {}
type _ (line 458) | struct _ {
function ThrowThunk (line 467) | inline constexpr ThrowThunk throw_() noexcept {
function inSitu (line 472) | constexpr bool inSitu() noexcept {
function State (line 496) | enum class State : short { eEmpty, eInSitu, eOnHeap };
function decltype (line 761) | static auto call(This&& _this, As&&... args)
function Data (line 812) | Data const* data(PolyRoot<I> const& _this) noexcept {
type MakePolyNode (line 845) | struct MakePolyNode {
function Fun (line 881) | Fun T::*operator()(Fun T::*t) const /* nolint */ volatile noexcept {
function F (line 885) | F T::*operator()(F T::*t) const /* nolint */ volatile noexcept {
function Fun (line 912) | constexpr Fun* operator()(Fun* t) const noexcept {
function F (line 916) | F* operator()(F* t) const noexcept {
function CCFun (line 933) | constexpr CCFun* operator()(CCFun* t) const /* nolint */ volatile noexce...
FILE: example/ios/Pods/Folly/folly/detail/RangeCommon.h
function namespace (line 25) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/RangeSse42.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/Singleton.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/SingletonStackTrace.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/SlowFingerprint.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/SocketFastOpen.h
function namespace (line 31) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/Sse.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/detail/StaticSingletonManager.h
function class (line 32) | class StaticSingletonManagerSansRtti {
function class (line 56) | class StaticSingletonManagerWithRtti {
FILE: example/ios/Pods/Folly/folly/detail/ThreadLocalDetail.h
function namespace (line 56) | namespace folly {
function guard (line 145) | auto guard = makeGuard([&] { delete p; }
function guard (line 162) | auto guard = makeGuard([&] {
function cleanup (line 182) | void cleanup() {
type StaticMetaBase (line 200) | struct StaticMetaBase
type ThreadEntryList (line 201) | struct ThreadEntryList
type ThreadEntry (line 211) | struct ThreadEntry {
function ThreadEntryList (line 214) | ThreadEntryList* list{nullptr};
function class (line 262) | class PthreadKeyUnregister {
type StaticMetaBase (line 305) | struct StaticMetaBase {
function getOrInvalid (line 330) | uint32_t getOrInvalid() {
function getOrAllocate (line 338) | uint32_t getOrAllocate(StaticMetaBase& meta) {
function elementsCapacity (line 358) | uint32_t elementsCapacity() const;
function ElementWrapper (line 429) | static ElementWrapper& get(EntryID* ent) {
function ThreadEntry (line 461) | static ThreadEntry* getThreadEntrySlow() {
function preFork (line 499) | static bool preFork() {
function onForkParent (line 503) | static void onForkParent() {
function onForkChild (line 507) | static void onForkChild() {
FILE: example/ios/Pods/Folly/folly/detail/TurnSequencer.h
function isTurn (line 85) | bool isTurn(const uint32_t turn) const noexcept {
function TryWaitResult (line 90) | enum class TryWaitResult { SUCCESS, PAST, TIMEDOUT };
FILE: example/ios/Pods/Folly/folly/detail/TypeList.h
function namespace (line 74) | namespace folly {
function namespace (line 385) | namespace impl {
function namespace (line 423) | namespace impl {
function namespace (line 443) | namespace impl {
type Join_ (line 521) | struct Join_ {
FILE: example/ios/Pods/Folly/folly/detail/UniqueInstance.cpp
type folly (line 28) | namespace folly {
type detail (line 29) | namespace detail {
type PtrRange (line 34) | struct PtrRange {
function PtrRange (line 40) | PtrRange ptr_range_key(Value value) {
function PtrRange (line 46) | PtrRange ptr_range_mapped(Value value) {
function equal (line 51) | bool equal(PtrRange lhs, PtrRange rhs) {
function join (line 56) | std::string join(PtrRange types) {
function render (line 68) | std::string render(Value value) {
FILE: example/ios/Pods/Folly/folly/detail/UniqueInstance.h
function namespace (line 24) | namespace folly {
FILE: example/ios/Pods/Folly/folly/dynamic-inl.h
function namespace (line 28) | namespace folly {
type DynamicKeyEqual (line 45) | struct DynamicKeyEqual {
function namespace (line 83) | namespace std {
function namespace (line 129) | namespace folly {
type dynamic (line 287) | struct dynamic
type dynamic (line 307) | struct dynamic
function Super (line 319) | const_value_iterator(value_iterator i) : Super(i.base()) {}
function dynamic (line 332) | inline dynamic::dynamic() : dynamic(nullptr) {}
type dynamic (line 384) | struct dynamic
type dynamic (line 388) | struct dynamic
type dynamic (line 392) | struct dynamic
function dynamic (line 396) | inline dynamic::dynamic(std::vector<bool>::reference b)
function dynamic (line 398) | inline dynamic::dynamic(VectorBoolConstRefCtorType b)
type It (line 432) | typedef It iterator;
type typename (line 433) | typedef typename It::value_type value_type;
type typename (line 434) | typedef typename It::object_type object_type;
function o_ (line 436) | o_(o) {}
function dynamic (line 465) | inline dynamic::IterableProxy<dynamic::value_iterator> dynamic::values() {
function dynamic (line 469) | inline dynamic::IterableProxy<dynamic::item_iterator> dynamic::items() {
function std (line 515) | inline const std::string& dynamic::getString() const& {
function comp (line 566) | static bool comp(T const& a, T const& b) {
function ObjectImpl (line 571) | struct dynamic::CompareOp<dynamic::ObjectImpl> {
type dynamic (line 578) | struct dynamic
function comp (line 579) | static bool comp(std::nullptr_t const&, std::nullptr_t const&) {
function dynamic (line 584) | inline dynamic& dynamic::operator+=(dynamic const& o) {
function dynamic (line 593) | inline dynamic& dynamic::operator-=(dynamic const& o) {
function dynamic (line 598) | inline dynamic& dynamic::operator*=(dynamic const& o) {
function dynamic (line 603) | inline dynamic& dynamic::operator/=(dynamic const& o) {
function dynamic (line 755) | dynamic const*> dynamic::get_ptr(
function dynamic (line 766) | inline dynamic* dynamic::get_ptr(StringPiece idx) & {
function dynamic (line 791) | inline dynamic* dynamic::get_ptr(json_pointer const& jsonPtr) & {
function dynamic (line 797) | dynamic const&> dynamic::at(
function dynamic (line 812) | inline dynamic& dynamic::at(StringPiece idx) & {
function dynamic (line 816) | inline dynamic&& dynamic::at(StringPiece idx) && {
function count (line 853) | inline std::size_t dynamic::count(StringPiece key) const {
function update (line 869) | inline void dynamic::update(const dynamic& mergeObj) {
type dynamic (line 1074) | struct dynamic
function Array (line 1080) | struct dynamic::GetAddrImpl<dynamic::Array> {
type dynamic (line 1086) | struct dynamic
type dynamic (line 1092) | struct dynamic
type dynamic (line 1098) | struct dynamic
function string (line 1104) | struct dynamic::GetAddrImpl<std::string> {
function ObjectImpl (line 1110) | struct dynamic::GetAddrImpl<dynamic::ObjectImpl> {
function print (line 1144) | static void print(dynamic const&, std::ostream& out, T const& t) {
type dynamic (line 1150) | struct dynamic
function print (line 1151) | static void
function ObjectImpl (line 1157) | struct dynamic::PrintImpl<dynamic::ObjectImpl> {
function Array (line 1164) | struct dynamic::PrintImpl<dynamic::Array> {
function print (line 1171) | inline void dynamic::print(std::ostream& out) const {
FILE: example/ios/Pods/Folly/folly/dynamic.cpp
type folly (line 29) | namespace folly {
function dynamic (line 128) | dynamic& dynamic::operator=(dynamic const& o) {
function dynamic (line 145) | dynamic& dynamic::operator=(dynamic&& o) noexcept {
function dynamic (line 162) | dynamic const& dynamic::atImpl(dynamic const& idx) const& {
function dynamic (line 183) | dynamic const& dynamic::at(StringPiece idx) const& {
function dynamic (line 196) | dynamic& dynamic::operator[](StringPiece k) & {
function dynamic (line 202) | dynamic dynamic::getDefault(StringPiece k, const dynamic& v) const& {
function dynamic (line 208) | dynamic dynamic::getDefault(StringPiece k, dynamic&& v) const& {
function dynamic (line 219) | dynamic dynamic::getDefault(StringPiece k, const dynamic& v) && {
function dynamic (line 230) | dynamic dynamic::getDefault(StringPiece k, dynamic&& v) && {
function dynamic (line 236) | const dynamic* dynamic::get_ptrImpl(dynamic const& idx) const& {
function dynamic (line 256) | const dynamic* dynamic::get_ptr(StringPiece idx) const& {
function dynamic (line 336) | dynamic dynamic::merge_diff(const dynamic& source, const dynamic& targ...
function dynamic (line 438) | const dynamic* dynamic::get_ptr(json_pointer const& jsonPtr) const& {
FILE: example/ios/Pods/Folly/folly/dynamic.h
type dynamic (line 75) | struct dynamic
type TypeError (line 76) | struct TypeError
type dynamic (line 80) | struct dynamic
type Type (line 81) | enum Type {
function false_type (line 112) | struct VectorBoolConstRefFake : std::false_type {}
type Array (line 120) | typedef Array::const_iterator const_iterator;
type dynamic (line 121) | typedef dynamic value_type;
type const_key_iterator (line 123) | struct const_key_iterator
type const_value_iterator (line 124) | struct const_value_iterator
type const_item_iterator (line 125) | struct const_item_iterator
type value_iterator (line 127) | struct value_iterator
type item_iterator (line 128) | struct item_iterator
type EmptyArrayTag (line 150) | struct EmptyArrayTag {}
type ObjectMaker (line 151) | struct ObjectMaker
FILE: example/ios/Pods/Folly/folly/functional/ApplyTuple.h
function namespace (line 27) | namespace folly {
function namespace (line 210) | namespace detail {
FILE: example/ios/Pods/Folly/folly/functional/Invoke.h
function namespace (line 49) | namespace folly {
function namespace (line 56) | namespace folly {
function namespace (line 79) | namespace folly {
function namespace (line 96) | namespace folly {
function namespace (line 201) | namespace folly {
FILE: example/ios/Pods/Folly/folly/functional/Partial.h
type PartialConstructFromCallable (line 32) | struct PartialConstructFromCallable {}
FILE: example/ios/Pods/Folly/folly/hash/Checksum.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/hash/FarmHash.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/hash/Hash.h
function namespace (line 40) | namespace folly {
function const (line 459) | size_t operator()(bool key) const noexcept {
type hasher (line 468) | struct hasher
type hasher (line 472) | struct hasher
type hasher (line 475) | struct hasher
type hasher (line 478) | struct hasher
type hasher (line 481) | struct hasher
type hasher (line 484) | struct hasher
type hasher (line 487) | struct hasher
type hasher (line 490) | struct hasher
type hasher (line 493) | struct hasher
type hasher (line 496) | struct hasher
type hasher (line 503) | struct hasher
type hasher (line 506) | struct hasher
type hasher (line 511) | struct hasher
type hasher (line 514) | struct hasher
function string (line 517) | struct hasher<std::string> {
function const (line 530) | size_t operator()(T key) const noexcept {
function const (line 544) | size_t operator()(const std::pair<T1, T2>& key) const {
function const (line 560) | size_t operator()(T* key) const {
function const (line 569) | size_t operator()(const std::unique_ptr<T>& key) const {
function const (line 578) | size_t operator()(const std::shared_ptr<T>& key) const {
function namespace (line 591) | namespace hash {
function const (line 716) | size_t operator()(std::tuple<Ts...> const& key) const {
function namespace (line 735) | namespace std {
FILE: example/ios/Pods/Folly/folly/hash/SpookyHashV1.h
function namespace (line 50) | namespace folly {
FILE: example/ios/Pods/Folly/folly/hash/SpookyHashV2.cpp
type folly (line 36) | namespace folly {
type hash (line 37) | namespace hash {
FILE: example/ios/Pods/Folly/folly/hash/SpookyHashV2.h
function namespace (line 51) | namespace folly {
FILE: example/ios/Pods/Folly/folly/json.cpp
type folly (line 35) | namespace folly {
type json (line 39) | namespace json {
function parse_error (line 43) | parse_error make_parse_error(
type Printer (line 55) | struct Printer {
method Printer (line 56) | explicit Printer(
method printKV (line 105) | void printKV(const std::pair<const dynamic, dynamic>& p) const {
method printKVPairs (line 117) | void printKVPairs(Iterator begin, Iterator end) const {
method printObject (line 126) | void printObject(dynamic const& o) const {
method printArray (line 158) | void printArray(dynamic const& a) const {
method outdent (line 179) | void outdent() const {
method indent (line 185) | void indent() const {
method newline (line 191) | void newline() const {
method mapColon (line 197) | void mapColon() const {
type Input (line 210) | struct Input {
method Input (line 211) | explicit Input(StringPiece range, json::serialization_opts const* ...
method Input (line 216) | Input(Input const&) = delete;
method Input (line 217) | Input& operator=(Input const&) = delete;
method getLineNum (line 223) | unsigned getLineNum() const {
method StringPiece (line 230) | StringPiece skipWhile(const Predicate& p) {
method StringPiece (line 246) | StringPiece skipDigits() {
method StringPiece (line 250) | StringPiece skipMinusAndDigits() {
method skipWhitespace (line 259) | void skipWhitespace() {
method expect (line 282) | void expect(char c) {
method size (line 290) | std::size_t size() const {
method T (line 304) | T extract() {
method consume (line 312) | bool consume(StringPiece str) {
method context (line 321) | std::string context() const {
method dynamic (line 325) | dynamic error(char const* what) const {
method incrementRecursionLevel (line 333) | void incrementRecursionLevel() {
method decrementRecursionLevel (line 340) | void decrementRecursionLevel() {
method storeCurrent (line 345) | void storeCurrent() {
class RecursionGuard (line 357) | class RecursionGuard {
method RecursionGuard (line 359) | explicit RecursionGuard(Input& in) : in_(in) {
function parseObjectKeyValue (line 376) | void parseObjectKeyValue(
function dynamic (line 400) | dynamic parseObject(Input& in, json::metadata_map* map) {
function dynamic (line 438) | dynamic parseArray(Input& in, json::metadata_map* map) {
function dynamic (line 476) | dynamic parseNumber(Input& in) {
function decodeUnicodeEscape (line 533) | std::string decodeUnicodeEscape(Input& in) {
function parseString (line 584) | std::string parseString(Input& in) {
function dynamic (line 638) | dynamic parseValue(Input& in, json::metadata_map* map) {
function buildExtraAsciiToEscapeBitmap (line 665) | std::array<uint64_t, 2> buildExtraAsciiToEscapeBitmap(StringPiece ch...
function serialize (line 675) | std::string serialize(dynamic const& dyn, serialization_opts const& ...
function firstEscapableInWord (line 687) | size_t firstEscapableInWord(T s, const serialization_opts& opts) {
function escapeStringImpl (line 742) | void escapeStringImpl(
function escapeString (line 878) | void escapeString(
function stripComments (line 891) | std::string stripComments(StringPiece jsonC) {
function dynamic (line 954) | dynamic parseJsonWithMetadata(StringPiece range, json::metadata_map* m...
function dynamic (line 958) | dynamic parseJsonWithMetadata(
function dynamic (line 977) | dynamic parseJson(StringPiece range) {
function dynamic (line 981) | dynamic parseJson(StringPiece range, json::serialization_opts const& o...
function toJson (line 992) | std::string toJson(dynamic const& dyn) {
function toPrettyJson (line 996) | std::string toPrettyJson(dynamic const& dyn) {
function PrintTo (line 1015) | void PrintTo(const dynamic& dyn, std::ostream* os) {
FILE: example/ios/Pods/Folly/folly/json.h
function namespace (line 50) | namespace folly {
FILE: example/ios/Pods/Folly/folly/json_patch.h
function namespace (line 24) | namespace folly {
FILE: example/ios/Pods/Folly/folly/json_pointer.cpp
type folly (line 21) | namespace folly {
function json_pointer (line 49) | json_pointer json_pointer::parse(StringPiece const str) {
FILE: example/ios/Pods/Folly/folly/json_pointer.h
function namespace (line 25) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/Align.h
function namespace (line 24) | namespace folly {
type alignas (line 106) | struct alignas
type alignas (line 142) | struct alignas
FILE: example/ios/Pods/Folly/folly/lang/Aligned.h
function namespace (line 26) | namespace folly {
function T (line 76) | T* get() noexcept {
function T (line 79) | T const* get() const noexcept {
function T (line 85) | T const* operator->() const noexcept {
FILE: example/ios/Pods/Folly/folly/lang/Assume.cpp
type folly (line 21) | namespace folly {
type detail (line 23) | namespace detail {
function assume_check (line 25) | void assume_check(bool cond) {
FILE: example/ios/Pods/Folly/folly/lang/Assume.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/Bits.h
function namespace (line 67) | namespace folly {
function FOLLY_PACK_POP (line 327) | FOLLY_PACK_POP
FILE: example/ios/Pods/Folly/folly/lang/CString.cpp
type folly (line 21) | namespace folly {
function strlcpy (line 23) | std::size_t
FILE: example/ios/Pods/Folly/folly/lang/CString.h
function namespace (line 22) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/Cast.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/CheckedMath.h
function namespace (line 25) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/Exception.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/Launder.h
function namespace (line 34) | namespace folly {
function namespace (line 42) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/Ordering.h
function namespace (line 19) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/Pretty.h
function namespace (line 24) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/PropagateConst.h
function namespace (line 26) | namespace folly {
function namespace (line 41) | namespace detail {
function swap (line 127) | constexpr void swap(propagate_const& other) noexcept(
function element_type (line 134) | constexpr element_type* get() {
function element_type (line 138) | constexpr element_type const* get() const {
function const (line 352) | size_t operator()(folly::propagate_const<Pointer> const& obj) const {
FILE: example/ios/Pods/Folly/folly/lang/RValueReferenceWrapper.h
function namespace (line 23) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/SafeAssert.cpp
type folly (line 24) | namespace folly {
type detail (line 25) | namespace detail {
function writeStderr (line 444) | void writeStderr(const char* s, size_t len) {
function writeStderr (line 447) | void writeStderr(const char* s) {
function assertionFailure (line 453) | void assertionFailure(
FILE: example/ios/Pods/Folly/folly/lang/SafeAssert.h
function namespace (line 56) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/StaticConst.h
function namespace (line 19) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/TypeInfo.h
function namespace (line 33) | namespace folly {
FILE: example/ios/Pods/Folly/folly/lang/UncaughtExceptions.h
function namespace (line 23) | namespace __cxxabiv1 {
function namespace (line 41) | namespace folly {
FILE: example/ios/Pods/Folly/folly/memory/Arena-inl.h
function namespace (line 23) | namespace folly {
function disposer (line 90) | auto disposer = [this](Block* b) { b->deallocate(this->alloc()); }
FILE: example/ios/Pods/Folly/folly/memory/Arena.h
function namespace (line 35) | namespace folly {
type Block (line 129) | struct Block
type boost (line 130) | typedef boost::intrusive::slist_member_hook<boost::intrusive::tag<Arena>>
type alignas (line 133) | struct alignas
function isAligned (line 163) | bool isAligned(void* p) const {
function roundUp (line 168) | size_t roundUp(size_t size) const {
type boost (line 179) | typedef boost::intrusive::slist<
function Alloc (line 190) | struct AllocAndSize : public Alloc {
function goodSize (line 225) | static size_t goodSize(const Alloc& /* alloc */, size_t size) {
type ArenaAllocatorTraits (line 231) | struct ArenaAllocatorTraits
function goodSize (line 232) | static size_t goodSize(const SysAllocator<void>& /* alloc */, size_t siz...
function class (line 240) | class SysArena : public Arena<SysAllocator<void>> {
function true_type (line 250) | struct AllocatorHasTrivialDeallocate<SysArena> : std::true_type {}
FILE: example/ios/Pods/Folly/folly/memory/EnableSharedFromThis.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/memory/MallctlHelper.h
function namespace (line 26) | namespace folly {
function mallctlCall (line 62) | inline void mallctlCall(const char* cmd) {
FILE: example/ios/Pods/Folly/folly/memory/Malloc.h
function namespace (line 56) | namespace folly {
FILE: example/ios/Pods/Folly/folly/memory/MemoryResource.h
function namespace (line 25) | namespace folly {
function namespace (line 37) | namespace folly {
FILE: example/ios/Pods/Folly/folly/memory/SanitizeLeak.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/memory/ThreadCachedArena.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/memory/UninitializedMemoryHacks.h
type FollyMemoryDetailTranslationUnitTag (line 32) | struct FollyMemoryDetailTranslationUnitTag {}
function namespace (line 34) | namespace folly {
function namespace (line 144) | namespace folly {
function namespace (line 169) | namespace folly {
function namespace (line 194) | namespace folly {
FILE: example/ios/Pods/Folly/folly/net/NetOps.cpp
type folly (line 35) | namespace folly {
type netops (line 36) | namespace netops {
type WinSockInit (line 41) | struct WinSockInit {
method WinSockInit (line 42) | WinSockInit() {
function translate_wsa_error (line 51) | int translate_wsa_error(int wsaErr) {
function R (line 62) | static R wrapSocketFunction(F f, NetworkSocket s, Args... args) {
function NetworkSocket (line 71) | NetworkSocket accept(NetworkSocket s, sockaddr* addr, socklen_t* add...
function bind (line 76) | int bind(NetworkSocket s, const sockaddr* name, socklen_t namelen) {
function close (line 90) | int close(NetworkSocket s) {
function connect (line 94) | int connect(NetworkSocket s, const sockaddr* name, socklen_t namelen) {
function getpeername (line 104) | int getpeername(NetworkSocket s, sockaddr* name, socklen_t* namelen) {
function getsockname (line 108) | int getsockname(NetworkSocket s, sockaddr* name, socklen_t* namelen) {
function getsockopt (line 112) | int getsockopt(
function inet_aton (line 132) | int inet_aton(const char* cp, in_addr* inp) {
function listen (line 137) | int listen(NetworkSocket s, int backlog) {
function poll (line 141) | int poll(PollDescriptor fds[], nfds_t nfds, int timeout) {
function recv (line 180) | ssize_t recv(NetworkSocket s, void* buf, size_t len, int flags) {
function recvfrom (line 207) | ssize_t recvfrom(
function recvmsg (line 268) | ssize_t recvmsg(NetworkSocket s, msghdr* message, int flags) {
function send (line 319) | ssize_t send(NetworkSocket s, const void* buf, size_t len, int flags) {
function sendmsg (line 328) | ssize_t sendmsg(NetworkSocket socket, const msghdr* message, int fla...
function sendmmsg (line 369) | int sendmmsg(
function sendto (line 396) | ssize_t sendto(
function setsockopt (line 411) | int setsockopt(
function shutdown (line 435) | int shutdown(NetworkSocket s, int how) {
function NetworkSocket (line 439) | NetworkSocket socket(int af, int type, int protocol) {
function socketpair (line 443) | int socketpair(int domain, int type, int protocol, NetworkSocket sv[...
function set_socket_non_blocking (line 468) | int set_socket_non_blocking(NetworkSocket s) {
function set_socket_close_on_exec (line 481) | int set_socket_close_on_exec(NetworkSocket s) {
FILE: example/ios/Pods/Folly/folly/net/NetOps.h
type mmsghdr (line 76) | struct mmsghdr {
type msghdr (line 104) | struct msghdr {
type mmsghdr (line 114) | struct mmsghdr {
type sockaddr_un (line 119) | struct sockaddr_un {
function namespace (line 142) | namespace folly {
FILE: example/ios/Pods/Folly/folly/net/NetworkSocket.h
function namespace (line 24) | namespace folly {
function namespace (line 77) | namespace std {
FILE: example/ios/Pods/Folly/folly/net/detail/SocketFileDescriptorMap.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Asm.h
function namespace (line 27) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Atomic.h
function FOLLY_ALWAYS_INLINE (line 26) | FOLLY_ALWAYS_INLINE
FILE: example/ios/Pods/Folly/folly/portability/Builtins.h
function namespace (line 25) | namespace folly {
function FOLLY_ALWAYS_INLINE (line 33) | FOLLY_ALWAYS_INLINE void __builtin___clear_cache(char* begin, char* end) {
function FOLLY_ALWAYS_INLINE (line 45) | FOLLY_ALWAYS_INLINE int __builtin_clz(unsigned int x) {
function FOLLY_ALWAYS_INLINE (line 50) | FOLLY_ALWAYS_INLINE int __builtin_clzl(unsigned long x) {
function FOLLY_ALWAYS_INLINE (line 55) | FOLLY_ALWAYS_INLINE int __builtin_clzll(unsigned long long x) {
function FOLLY_ALWAYS_INLINE (line 64) | FOLLY_ALWAYS_INLINE int __builtin_clzll(unsigned long long x) {
function FOLLY_ALWAYS_INLINE (line 70) | FOLLY_ALWAYS_INLINE int __builtin_ctz(unsigned int x) {
function FOLLY_ALWAYS_INLINE (line 75) | FOLLY_ALWAYS_INLINE int __builtin_ctzl(unsigned long x) {
function FOLLY_ALWAYS_INLINE (line 80) | FOLLY_ALWAYS_INLINE int __builtin_ctzll(unsigned long long x) {
function FOLLY_ALWAYS_INLINE (line 91) | FOLLY_ALWAYS_INLINE int __builtin_ctzll(unsigned long long x) {
function FOLLY_ALWAYS_INLINE (line 98) | FOLLY_ALWAYS_INLINE int __builtin_ffs(int x) {
function FOLLY_ALWAYS_INLINE (line 103) | FOLLY_ALWAYS_INLINE int __builtin_ffsl(long x) {
function FOLLY_ALWAYS_INLINE (line 108) | FOLLY_ALWAYS_INLINE int __builtin_ffsll(long long x) {
function FOLLY_ALWAYS_INLINE (line 113) | FOLLY_ALWAYS_INLINE int __builtin_ffsll(long long x) {
function FOLLY_ALWAYS_INLINE (line 118) | FOLLY_ALWAYS_INLINE int __builtin_popcount(unsigned int x) {
function FOLLY_ALWAYS_INLINE (line 123) | FOLLY_ALWAYS_INLINE int __builtin_popcountl(unsigned long x) {
function FOLLY_ALWAYS_INLINE (line 132) | FOLLY_ALWAYS_INLINE int __builtin_popcountll(unsigned long long x) {
function FOLLY_ALWAYS_INLINE (line 137) | FOLLY_ALWAYS_INLINE int __builtin_popcountll(unsigned long long x) {
function FOLLY_ALWAYS_INLINE (line 143) | FOLLY_ALWAYS_INLINE void* __builtin_return_address(unsigned int frame) {
FILE: example/ios/Pods/Folly/folly/portability/Constexpr.h
function namespace (line 25) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Dirent.h
type dirent (line 27) | struct dirent {
type DIR (line 32) | struct DIR
FILE: example/ios/Pods/Folly/folly/portability/Event.h
function namespace (line 33) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Fcntl.h
function namespace (line 44) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/GFlags.h
function namespace (line 65) | namespace google {
FILE: example/ios/Pods/Folly/folly/portability/IOVec.h
type iovec (line 30) | struct iovec {
FILE: example/ios/Pods/Folly/folly/portability/Libgen.h
function namespace (line 19) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Math.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Memory.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/OpenSSL.h
function namespace (line 117) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/PThread.h
function namespace (line 47) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Sched.h
function namespace (line 26) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Semaphore.h
function namespace (line 25) | namespace folly::portability::semaphore {
FILE: example/ios/Pods/Folly/folly/portability/Sockets.h
function namespace (line 21) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/SysMembarrier.h
function namespace (line 19) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/SysResource.h
type rlimit (line 39) | struct rlimit {
type rusage (line 44) | struct rusage {
FILE: example/ios/Pods/Folly/folly/portability/SysStat.h
type stat (line 46) | struct stat
FILE: example/ios/Pods/Folly/folly/portability/SysTime.h
type timezone (line 24) | struct timezone {
type timezone (line 38) | struct timezone
FILE: example/ios/Pods/Folly/folly/portability/SysUio.cpp
function wrapPositional (line 28) | static int wrapPositional(F f, int fd, off_t offset, Args... args) {
function preadv (line 52) | ssize_t preadv(int fd, const iovec* iov, int count, off_t offset) {
function pwritev (line 58) | ssize_t pwritev(int fd, const iovec* iov, int count, off_t offset) {
function doVecOperation (line 65) | static ssize_t doVecOperation(int fd, const iovec* iov, int count) {
function readv (line 130) | ssize_t readv(int fd, const iovec* iov, int count) {
function writev (line 134) | ssize_t writev(int fd, const iovec* iov, int count) {
FILE: example/ios/Pods/Folly/folly/portability/SysUio.h
function namespace (line 35) | namespace folly {
FILE: example/ios/Pods/Folly/folly/portability/Syslog.h
function openlog (line 34) | inline void openlog(const char*, int, int) {}
function closelog (line 35) | inline void closelog() {}
function syslog (line 36) | inline void syslog(int, const char*, ...) {}
FILE: example/ios/Pods/Folly/folly/portability/Time.h
type clockid_t (line 51) | typedef uint8_t clockid_t;
type timespec (line 52) | struct timespec
type timespec (line 53) | struct timespec
type timespec (line 64) | struct timespec
type timespec (line 64) | struct timespec
type tm (line 68) | struct tm
FILE: example/ios/Pods/Folly/folly/portability/Unistd.h
function namespace (line 58) | namespace folly {
FILE: example/ios/Pods/Folly/folly/small_vector.h
function namespace (line 76) | namespace small_vector_policy {
function namespace (line 97) | namespace detail {
function rollback (line 189) | auto rollback = makeGuard([&] {
type SizeType (line 204) | typedef SizeType InternalSizeType;
function setExtern (line 221) | void setExtern(bool b) {
function setSize (line 229) | void setSize(std::size_t sz) {
function swapSizePolicy (line 234) | void swapSizePolicy(IntegralSizePolicyBase& o) {
function rollback (line 264) | auto rollback = makeGuard([&] {
function rollback (line 309) | auto rollback = makeGuard([&] { //
function rollback (line 317) | auto rollback = makeGuard([&] {
type mpl (line 368) | typedef mpl::vector<InPolicyA, InPolicyB, InPolicyC> PolicyList;
type typename (line 373) | typedef typename mpl::filter_view<
type typename (line 376) | typedef typename mpl::eval_if<
type typename (line 391) | typedef typename mpl::count<PolicyList, small_vector_policy::NoHeap>::type
type IntegralSizePolicy (line 402) | typedef IntegralSizePolicy<SizeType, !HasNoHeap::value> ActualSizePolicy;
type boost (line 409) | typedef boost::totally_ordered1<
type typename (line 446) | typedef typename detail::
type typename (line 449) | typedef typename BaseType::InternalSizeType InternalSizeType;
function MaxInline (line 456) | static constexpr std::size_t MaxInline{
function explicit (line 511) | explicit small_vector(size_type n) {
function iterator (line 577) | iterator begin() {
function iterator (line 580) | iterator end() {
function reverse_iterator (line 596) | reverse_iterator rbegin() {
function reverse_iterator (line 599) | reverse_iterator rend() {
function swap (line 626) | void swap(small_vector& o) {
function resize (line 707) | void resize(size_type sz) {
function resize (line 718) | void resize(size_type sz, value_type const& v) {
function value_type (line 729) | value_type* data() noexcept {
function value_type (line 733) | value_type const* data() const noexcept {
function reserve (line 763) | void reserve(size_type sz) {
function shrink_to_fit (line 777) | void shrink_to_fit() {
function push_back (line 803) | void push_back(value_type&& t) {
function push_back (line 807) | void push_back(value_type const& t) {
function pop_back (line 811) | void pop_back() {
function iterator (line 815) | iterator insert(const_iterator constp, value_type&& t) {
function iterator (line 846) | iterator insert(const_iterator p, value_type const& t) {
function iterator (line 852) | iterator insert(const_iterator pos, size_type n, value_type const& val) {
function iterator (line 876) | iterator insert(const_iterator p, std::initializer_list<value_type> il) {
function iterator (line 880) | iterator erase(const_iterator q) {
function iterator (line 887) | iterator erase(const_iterator q1, const_iterator q2) {
function clear (line 899) | void clear() {
function assign (line 909) | void assign(std::initializer_list<value_type> il) {
function assign (line 913) | void assign(size_type n, const value_type& t) {
function reference (line 918) | reference front() {
function reference (line 922) | reference back() {
function reference (line 935) | reference operator[](size_type i) {
function const_reference (line 940) | const_reference operator[](size_type i) const {
function reference (line 945) | reference at(size_type i) {
function const_reference (line 952) | const_reference at(size_type i) const {
function iterator (line 996) | iterator
type typename (line 1008) | typedef typename std::iterator_traits<It>::iterator_category categ;
function rollback (line 1022) | auto rollback = makeGuard([&] {
function rollback (line 1038) | auto rollback = makeGuard([&] {
function constructImpl (line 1050) | void constructImpl(size_type n, value_type const& val, std::true_type) {
function size_type (line 1057) | size_type computeNewSize() const {
function rollback (line 1126) | auto rollback = makeGuard([&] { //
type typename (line 1215) | typedef typename std::
function value_type (line 1227) | value_type* buffer() noexcept {
function value_type (line 1231) | value_type const* buffer() const noexcept {
function value_type (line 1234) | value_type* heap() noexcept {
function value_type (line 1242) | value_type const* heap() const noexcept {
function setCapacity (line 1252) | void setCapacity(InternalSizeType c) {
function freeHeap (line 1256) | void freeHeap() {
function namespace (line 1293) | namespace detail {
FILE: example/ios/Pods/Folly/folly/sorted_vector_types.h
function namespace (line 82) | namespace folly {
type EBO (line 264) | struct EBO
type T (line 268) | typedef T key_type;
type Compare (line 269) | typedef Compare key_compare;
type Compare (line 270) | typedef Compare value_compare;
type Allocator (line 271) | typedef Allocator allocator_type;
type Container (line 272) | typedef Container container_type;
type typename (line 274) | typedef typename Container::pointer pointer;
type typename (line 275) | typedef typename Container::reference reference;
type typename (line 276) | typedef typename Container::const_reference const_reference;
type typename (line 282) | typedef typename Container::iterator iterator;
type typename (line 283) | typedef typename Container::const_iterator const_iterator;
type typename (line 284) | typedef typename Container::difference_type difference_type;
type typename (line 285) | typedef typename Container::size_type size_type;
type typename (line 286) | typedef typename Container::reverse_iterator reverse_iterator;
type typename (line 287) | typedef typename Container::const_reverse_iterator const_reverse_iterator;
function explicit (line 302) | explicit sorted_vector_set(const Allocator& alloc) : m_(Compare(), alloc...
function explicit (line 304) | explicit sorted_vector_set(
function explicit (line 355) | explicit sorted_vector_set(
function iterator (line 405) | iterator begin() {
function iterator (line 408) | iterator end() {
function reverse_iterator (line 423) | reverse_iterator rbegin() {
function reverse_iterator (line 426) | reverse_iterator rend() {
function clear (line 436) | void clear() {
function reserve (line 448) | void reserve(size_type s) {
function shrink_to_fit (line 451) | void shrink_to_fit() {
function iterator (line 476) | iterator insert(const_iterator hint, const value_type& value) {
function iterator (line 481) | iterator insert(const_iterator hint, value_type&& value) {
function insert (line 491) | void insert(std::initializer_list<value_type> ilist) {
function g (line 504) | auto g = makeGuard(
function g (line 526) | auto g = makeGuard(
function iterator (line 531) | iterator emplace_hint(const_iterator hint, const value_type& value) {
function iterator (line 535) | iterator emplace_hint(const_iterator hint, value_type&& value) {
function size_type (line 539) | size_type erase(const key_type& key) {
function iterator (line 548) | iterator erase(const_iterator it) {
function iterator (line 552) | iterator erase(const_iterator first, const_iterator last) {
function iterator (line 556) | iterator find(const key_type& key) {
function const_iterator (line 560) | const_iterator find(const key_type& key) const {
function size_type (line 574) | size_type count(const key_type& key) const {
function iterator (line 583) | iterator lower_bound(const key_type& key) {
function const_iterator (line 587) | const_iterator lower_bound(const key_type& key) const {
function iterator (line 601) | iterator upper_bound(const key_type& key) {
function const_iterator (line 605) | const_iterator upper_bound(const key_type& key) const {
function swap (line 641) | void swap(sorted_vector_set& o) {
function value_type (line 669) | const value_type* data() const noexcept {
type EBO (line 685) | struct EBO
function explicit (line 686) | explicit EBO(const Compare& c, const Allocator& alloc) noexcept(
function namespace (line 734) | namespace pmr {
type EBO (line 786) | struct EBO
type Value (line 790) | typedef Value mapped_type;
type typename (line 791) | typedef typename Container::value_type value_type;
type Compare (line 792) | typedef Compare key_compare;
type Allocator (line 793) | typedef Allocator allocator_type;
type Container (line 794) | typedef Container container_type;
function Compare (line 796) | struct value_compare : private Compare {
type typename (line 806) | typedef typename Container::pointer pointer;
type typename (line 807) | typedef typename Container::reference reference;
type typename (line 808) | typedef typename Container::const_reference const_reference;
type typename (line 809) | typedef typename Container::iterator iterator;
type typename (line 810) | typedef typename Container::const_iterator const_iterator;
type typename (line 811) | typedef typename Container::difference_type difference_type;
type typename (line 812) | typedef typename Container::size_type size_type;
type typename (line 813) | typedef typename Container::reverse_iterator reverse_iterator;
type typename (line 814) | typedef typename Container::const_reverse_iterator const_reverse_iterator;
function m_ (line 822) | sorted_vector_map(const sorted_vector_map& other, const Allocator& alloc)
function explicit (line 831) | explicit sorted_vector_map(const Allocator& alloc)
function explicit (line 834) | explicit sorted_vector_map(
function explicit (line 881) | explicit sorted_vector_map(
function iterator (line 932) | iterator begin() {
function iterator (line 935) | iterator end() {
function reverse_iterator (line 950) | reverse_iterator rbegin() {
function reverse_iterator (line 953) | reverse_iterator rend() {
function clear (line 963) | void clear() {
function reserve (line 975) | void reserve(size_type s) {
function shrink_to_fit (line 978) | void shrink_to_fit() {
function iterator (line 1003) | iterator insert(const_iterator hint, const value_type& value) {
function iterator (line 1008) | iterator insert(const_iterator hint, value_type&& value) {
function insert (line 1018) | void insert(std::initializer_list<value_type> ilist) {
function g (line 1031) | auto g = makeGuard(
function g (line 1053) | auto g = makeGuard(
function iterator (line 1058) | iterator emplace_hint(const_iterator hint, const value_type& value) {
function iterator (line 1062) | iterator emplace_hint(const_iterator hint, value_type&& value) {
function size_type (line 1066) | size_type erase(const key_type& key) {
function iterator (line 1075) | iterator erase(const_iterator it) {
function iterator (line 1079) | iterator erase(const_iterator first, const_iterator last) {
function iterator (line 1083) | iterator find(const key_type& key) {
function const_iterator (line 1087) | const_iterator find(const key_type& key) const {
function mapped_type (line 1109) | const mapped_type& at(const key_type& key) const {
function size_type (line 1117) | size_type count(const key_type& key) const {
function iterator (line 1126) | iterator lower_bound(const key_type& key) {
function const_iterator (line 1130) | const_iterator lower_bound(const key_type& key) const {
function iterator (line 1144) | iterator upper_bound(const key_type& key) {
function const_iterator (line 1148) | const_iterator upper_bound(const key_type& key) const {
function swap (line 1184) | void swap(sorted_vector_map& o) {
function value_type (line 1220) | const value_type* data() const noexcept {
type EBO (line 1227) | struct EBO
function explicit (line 1228) | explicit EBO(const value_compare& c, const Allocator& alloc) noexcept(
function namespace (line 1302) | namespace pmr {
FILE: example/ios/Pods/Folly/folly/stop_watch.h
function namespace (line 26) | namespace folly {
function duration (line 213) | duration lap() {
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/accumulators_fwd.hpp
type boost (line 55) | namespace boost { namespace accumulators
type accumulators (line 55) | namespace accumulators
type tag (line 61) | namespace tag
type sample (line 63) | struct sample
type weight (line 64) | struct weight
type accumulator (line 65) | struct accumulator
type weights (line 66) | struct weights
type value (line 75) | struct value
type value_tag (line 78) | struct value_tag
type reference (line 81) | struct reference
type reference_tag (line 84) | struct reference_tag
type external (line 87) | struct external
type droppable (line 90) | struct droppable
type tag (line 72) | namespace tag
type sample (line 63) | struct sample
type weight (line 64) | struct weight
type accumulator (line 65) | struct accumulator
type weights (line 66) | struct weights
type value (line 75) | struct value
type value_tag (line 78) | struct value_tag
type reference (line 81) | struct reference
type reference_tag (line 84) | struct reference_tag
type external (line 87) | struct external
type droppable (line 90) | struct droppable
type droppable_accumulator_base (line 94) | struct droppable_accumulator_base
type droppable_accumulator (line 97) | struct droppable_accumulator
type with_cached_result (line 100) | struct with_cached_result
type accumulator_set (line 103) | struct accumulator_set
type extractor (line 106) | struct extractor
type feature_of (line 109) | struct feature_of
type as_feature (line 112) | struct as_feature
type as_weighted_feature (line 115) | struct as_weighted_feature
type depends_on (line 118) | struct depends_on
type features (line 121) | struct features
type impl (line 166) | namespace impl
type external_impl (line 171) | struct external_impl
type detail (line 174) | namespace detail
type feature_tag (line 177) | struct feature_tag
type to_accumulator (line 180) | struct to_accumulator
type accumulator_set_base (line 182) | struct accumulator_set_base
type is_accumulator_set (line 185) | struct is_accumulator_set
function ignore_variable (line 187) | inline void ignore_variable(void const *) {}
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/accumulator_base.hpp
type boost (line 19) | namespace boost { namespace accumulators
type accumulators (line 19) | namespace accumulators
type detail (line 22) | namespace detail
type dont_care (line 30) | struct dont_care
method dont_care (line 33) | dont_care(Args const &)
type accumulator_base (line 41) | struct accumulator_base
method add_ref (line 50) | detail::void_ add_ref(dont_care)
method drop (line 54) | detail::void_ drop(dont_care)
method on_drop (line 58) | detail::void_ on_drop(dont_care)
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/accumulator_concept.hpp
type boost (line 13) | namespace boost { namespace accumulators
type accumulators (line 13) | namespace accumulators
type accumulator_concept (line 17) | struct accumulator_concept
method constraints (line 19) | void constraints()
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/accumulator_set.hpp
type boost (line 34) | namespace boost { namespace accumulators
type accumulators (line 34) | namespace accumulators
type detail (line 37) | namespace detail
type accumulator_visitor (line 43) | struct accumulator_visitor
method accumulator_visitor (line 45) | explicit accumulator_visitor(Args const &a)
function make_accumulator_visitor (line 62) | inline accumulator_visitor<Args> const make_accumulator_visitor(Ar...
type accumulator_set_base (line 77) | struct accumulator_set_base
type is_accumulator_set (line 84) | struct is_accumulator_set
type accumulator_set (line 107) | struct accumulator_set
method accumulator_set (line 139) | accumulator_set()
method accumulator_set (line 157) | explicit accumulator_set(A1 const &a1)
method visit (line 215) | void visit(UnaryFunction const &func)
method visit_if (line 225) | void visit_if(UnaryFunction const &func)
type apply (line 293) | struct apply
method drop (line 321) | void drop()
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/accumulators/droppable_accumulator.hpp
type boost (line 18) | namespace boost { namespace accumulators
type accumulators (line 18) | namespace accumulators
type droppable_accumulator (line 22) | struct droppable_accumulator
method droppable_accumulator (line 167) | droppable_accumulator(Args const &args)
method droppable_accumulator (line 172) | droppable_accumulator(droppable_accumulator const &that)
type detail (line 24) | namespace detail
type add_ref_visitor (line 30) | struct add_ref_visitor
method add_ref_visitor (line 32) | explicit add_ref_visitor(Args const &args)
function make_add_ref_visitor (line 57) | add_ref_visitor<Args> make_add_ref_visitor(Args const &args)
type drop_visitor (line 66) | struct drop_visitor
method drop_visitor (line 68) | explicit drop_visitor(Args const &args)
function make_drop_visitor (line 95) | drop_visitor<Args> make_drop_visitor(Args const &args)
type droppable_accumulator_base (line 104) | struct droppable_accumulator_base
method droppable_accumulator_base (line 112) | droppable_accumulator_base(Args const &args)
method droppable_accumulator_base (line 118) | droppable_accumulator_base(droppable_accumulator_base const &that)
method add_ref (line 134) | void add_ref(Args const &)
method drop (line 140) | void drop(Args const &args)
method is_dropped (line 150) | bool is_dropped() const
type droppable_accumulator (line 163) | struct droppable_accumulator
method droppable_accumulator (line 167) | droppable_accumulator(Args const &args)
method droppable_accumulator (line 172) | droppable_accumulator(droppable_accumulator const &that)
type with_cached_result (line 181) | struct with_cached_result
method with_cached_result (line 187) | with_cached_result(Args const &args)
method with_cached_result (line 193) | with_cached_result(with_cached_result const &that)
method on_drop (line 216) | void on_drop(Args const &args)
method result_type (line 224) | result_type result(Args const &args) const
method set (line 232) | void set(result_type const &r)
method result_type (line 237) | result_type const &get() const
method has_result (line 242) | bool has_result() const
type tag (line 252) | namespace tag
type as_droppable (line 255) | struct as_droppable
type as_droppable<droppable<Feature> > (line 261) | struct as_droppable<droppable<Feature> >
type droppable (line 269) | struct droppable
type impl (line 282) | struct impl
type apply (line 285) | struct apply
type as_feature<tag::droppable<Feature> > (line 299) | struct as_feature<tag::droppable<Feature> >
type as_weighted_feature<tag::droppable<Feature> > (line 307) | struct as_weighted_feature<tag::droppable<Feature> >
type feature_of<tag::droppable<Feature> > (line 315) | struct feature_of<tag::droppable<Feature> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/accumulators/external_accumulator.hpp
type boost (line 18) | namespace boost { namespace accumulators { namespace impl
type accumulators (line 18) | namespace accumulators { namespace impl
type impl (line 18) | namespace impl
type external_impl (line 26) | struct external_impl
method external_impl (line 32) | external_impl(dont_care) {}
method result_type (line 35) | result_type result(Args const &args) const
method result_type (line 43) | static result_type extract_(Args const &args, int)
method result_type (line 52) | static result_type extract_(Args const &, AccumulatorSet const &...
type tag (line 63) | namespace tag
type external (line 68) | struct external
type external<Feature, Tag, void> (line 80) | struct external<Feature, Tag, void>
type feature_of<tag::external<Feature, Tag, AccumulatorSet> > (line 95) | struct feature_of<tag::external<Feature, Tag, AccumulatorSet> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/accumulators/reference_accumulator.hpp
type accumulators (line 18) | namespace accumulators
type impl (line 21) | namespace impl
type reference_accumulator_impl (line 27) | struct reference_accumulator_impl
method reference_accumulator_impl (line 33) | reference_accumulator_impl(Args const &args)
method result_type (line 38) | result_type result(dont_care) const
type tag (line 48) | namespace tag
type reference_tag (line 53) | struct reference_tag
type reference (line 60) | struct reference
type extract (line 69) | namespace extract
type feature_of<tag::reference<ValueType, Tag> > (line 82) | struct feature_of<tag::reference<ValueType, Tag> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/accumulators/value_accumulator.hpp
type accumulators (line 17) | namespace accumulators
type impl (line 20) | namespace impl
type value_accumulator_impl (line 26) | struct value_accumulator_impl
method value_accumulator_impl (line 32) | value_accumulator_impl(Args const &args)
method result_type (line 37) | result_type result(dont_care) const
type tag (line 48) | namespace tag
type value_tag (line 53) | struct value_tag
type value (line 60) | struct value
type extract (line 69) | namespace extract
type feature_of<tag::value<ValueType, Tag> > (line 82) | struct feature_of<tag::value<ValueType, Tag> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/depends_on.hpp
type boost (line 47) | namespace boost { namespace accumulators
type accumulators (line 47) | namespace accumulators
type as_feature (line 52) | struct as_feature
type as_weighted_feature (line 60) | struct as_weighted_feature
type feature_of (line 68) | struct feature_of
type detail (line 73) | namespace detail
type feature_tag (line 78) | struct feature_tag
type undroppable (line 84) | struct undroppable
type undroppable<tag::droppable<Feature> > (line 90) | struct undroppable<tag::droppable<Feature> >
type is_dependent_on (line 98) | struct is_dependent_on
type dependencies_of (line 106) | struct dependencies_of
type set_insert_range (line 113) | struct set_insert_range
type collect_abstract_features (line 122) | struct collect_abstract_features
type depends_on_base (line 134) | struct depends_on_base
type matches_feature (line 177) | struct matches_feature
type apply (line 180) | struct apply
type contains_feature_of (line 189) | struct contains_feature_of
type contains_feature_of_ (line 208) | struct contains_feature_of_
type apply (line 211) | struct apply
type build_acc_list (line 221) | struct build_acc_list
type build_acc_list<First, Last, true> (line 224) | struct build_acc_list<First, Last, true>
method call (line 229) | static fusion::nil_
type build_acc_list<First, Last, false> (line 237) | struct build_acc_list<First, Last, false>
method type (line 249) | static type
type meta (line 256) | namespace meta
type make_acc_list (line 259) | struct make_acc_list
function make_acc_list (line 268) | typename meta::make_acc_list<Sequence>::type
type checked_as_weighted_feature (line 277) | struct checked_as_weighted_feature
type as_feature_list (line 293) | struct as_feature_list
type as_feature_list<Features, void> (line 299) | struct as_feature_list<Features, void>
type accumulator_wrapper (line 307) | struct accumulator_wrapper
method accumulator_wrapper (line 312) | accumulator_wrapper(accumulator_wrapper const &that)
method accumulator_wrapper (line 318) | accumulator_wrapper(Args const &args)
type to_accumulator (line 327) | struct to_accumulator
type to_accumulator<Feature, Sample, tag::external<Weight, Tag, AccumulatorSet> > (line 338) | struct to_accumulator<Feature, Sample, tag::external<Weight, Tag, ...
type insert_feature (line 361) | struct insert_feature
type insert_dependencies (line 371) | struct insert_dependencies
type insert_sequence (line 385) | struct insert_sequence
type make_accumulator_tuple (line 395) | struct make_accumulator_tuple
type depends_on (line 157) | struct depends_on
type detail (line 174) | namespace detail
type feature_tag (line 78) | struct feature_tag
type undroppable (line 84) | struct undroppable
type undroppable<tag::droppable<Feature> > (line 90) | struct undroppable<tag::droppable<Feature> >
type is_dependent_on (line 98) | struct is_dependent_on
type dependencies_of (line 106) | struct dependencies_of
type set_insert_range (line 113) | struct set_insert_range
type collect_abstract_features (line 122) | struct collect_abstract_features
type depends_on_base (line 134) | struct depends_on_base
type matches_feature (line 177) | struct matches_feature
type apply (line 180) | struct apply
type contains_feature_of (line 189) | struct contains_feature_of
type contains_feature_of_ (line 208) | struct contains_feature_of_
type apply (line 211) | struct apply
type build_acc_list (line 221) | struct build_acc_list
type build_acc_list<First, Last, true> (line 224) | struct build_acc_list<First, Last, true>
method call (line 229) | static fusion::nil_
type build_acc_list<First, Last, false> (line 237) | struct build_acc_list<First, Last, false>
method type (line 249) | static type
type meta (line 256) | namespace meta
type make_acc_list (line 259) | struct make_acc_list
function make_acc_list (line 268) | typename meta::make_acc_list<Sequence>::type
type checked_as_weighted_feature (line 277) | struct checked_as_weighted_feature
type as_feature_list (line 293) | struct as_feature_list
type as_feature_list<Features, void> (line 299) | struct as_feature_list<Features, void>
type accumulator_wrapper (line 307) | struct accumulator_wrapper
method accumulator_wrapper (line 312) | accumulator_wrapper(accumulator_wrapper const &that)
method accumulator_wrapper (line 318) | accumulator_wrapper(Args const &args)
type to_accumulator (line 327) | struct to_accumulator
type to_accumulator<Feature, Sample, tag::external<Weight, Tag, AccumulatorSet> > (line 338) | struct to_accumulator<Feature, Sample, tag::external<Weight, Tag, ...
type insert_feature (line 361) | struct insert_feature
type insert_dependencies (line 371) | struct insert_dependencies
type insert_sequence (line 385) | struct insert_sequence
type make_accumulator_tuple (line 395) | struct make_accumulator_tuple
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/extractor.hpp
type boost (line 27) | namespace boost { namespace accumulators
type accumulators (line 27) | namespace accumulators
type detail (line 30) | namespace detail
type accumulator_set_result (line 33) | struct accumulator_set_result
type argument_pack_result (line 40) | struct argument_pack_result
type extractor_result (line 51) | struct extractor_result
function do_extract (line 61) | typename extractor_result<AccumulatorSet, Feature>::type
function do_extract (line 69) | typename extractor_result<Args, Feature>::type
type extractor (line 82) | struct extractor
type result (line 88) | struct result
type result<this_type(A1)> (line 91) | struct result<this_type(A1)>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/features.hpp
type boost (line 15) | namespace boost { namespace accumulators
type accumulators (line 15) | namespace accumulators
type features (line 22) | struct features
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/parameters/accumulator.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/parameters/sample.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/parameters/weight.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/framework/parameters/weights.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/numeric/detail/function1.hpp
type boost (line 12) | namespace boost { namespace detail {
type detail (line 12) | namespace detail {
type function1 (line 21) | struct function1
type result (line 24) | struct result
type result<This(A0)> (line 28) | struct result<This(A0)>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/numeric/detail/function_n.hpp
type boost (line 27) | namespace boost { namespace detail {
type detail (line 27) | namespace detail {
type function_name (line 54) | struct function_name
type result (line 63) | struct result {}
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/numeric/detail/pod_singleton.hpp
type boost (line 7) | namespace boost { namespace detail {
type detail (line 7) | namespace detail {
type pod_singleton (line 10) | struct pod_singleton
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/numeric/functional.hpp
type std (line 49) | namespace std
type unary_function (line 53) | struct unary_function {}
type binary_function (line 56) | struct binary_function {}
type functional (line 62) | namespace functional
type are_integral (line 67) | struct are_integral
type left_ref (line 72) | struct left_ref
type detail (line 77) | namespace detail
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/numeric/functional/complex.hpp
type boost (line 22) | namespace boost { namespace numeric { namespace operators
type numeric (line 22) | namespace numeric { namespace operators
type operators (line 22) | namespace operators
type detail (line 53) | namespace detail
type one_complex (line 56) | struct one_complex
type one<std::complex<T> > (line 69) | struct one<std::complex<T> >
type numeric (line 51) | namespace numeric
type operators (line 22) | namespace operators
type detail (line 53) | namespace detail
type one_complex (line 56) | struct one_complex
type one<std::complex<T> > (line 69) | struct one<std::complex<T> >
type boost (line 51) | namespace boost { namespace numeric
type numeric (line 22) | namespace numeric { namespace operators
type operators (line 22) | namespace operators
type detail (line 53) | namespace detail
type one_complex (line 56) | struct one_complex
type one<std::complex<T> > (line 69) | struct one<std::complex<T> >
type numeric (line 51) | namespace numeric
type operators (line 22) | namespace operators
type detail (line 53) | namespace detail
type one_complex (line 56) | struct one_complex
type one<std::complex<T> > (line 69) | struct one<std::complex<T> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/numeric/functional/valarray.hpp
type operators (line 30) | namespace operators
type acc_detail (line 32) | namespace acc_detail
type make_valarray (line 35) | struct make_valarray
type std_valarray_tag (line 98) | struct std_valarray_tag
type tag<std::valarray<T> > (line 101) | struct tag<std::valarray<T> >
type tag<std::_Expr<T, U> > (line 108) | struct tag<std::_Expr<T, U> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/numeric/functional/vector.hpp
type boost (line 27) | namespace boost { namespace numeric
type numeric (line 27) | namespace numeric
type operators (line 29) | namespace operators
type acc_detail (line 31) | namespace acc_detail
type make_vector (line 34) | struct make_vector
type functional (line 184) | namespace functional
type std_vector_tag (line 186) | struct std_vector_tag
type tag<std::vector<T, Al> > (line 189) | struct tag<std::vector<T, Al> >
type min_assign<Left, Right, std_vector_tag, std_vector_tag> (line 197) | struct min_assign<Left, Right, std_vector_tag, std_vector_tag>
type max_assign<Left, Right, std_vector_tag, std_vector_tag> (line 216) | struct max_assign<Left, Right, std_vector_tag, std_vector_tag>
type fdiv<Left, Right, std_vector_tag, void> (line 234) | struct fdiv<Left, Right, std_vector_tag, void>
type promote<To, From, std_vector_tag, std_vector_tag> (line 244) | struct promote<To, From, std_vector_tag, std_vector_tag>
method To (line 247) | To operator ()(From &arr) const
type promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag> (line 259) | struct promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag>
method ToFrom (line 262) | ToFrom &operator ()(ToFrom &tofrom) const
type as_min<T, std_vector_tag> (line 271) | struct as_min<T, std_vector_tag>
type as_max<T, std_vector_tag> (line 285) | struct as_max<T, std_vector_tag>
type as_zero<T, std_vector_tag> (line 299) | struct as_zero<T, std_vector_tag>
type as_one<T, std_vector_tag> (line 313) | struct as_one<T, std_vector_tag>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/numeric/functional_fwd.hpp
type operators (line 20) | namespace operators
type op (line 23) | namespace op
type functional (line 30) | namespace functional
type tag (line 35) | struct tag
type tag<T const> (line 41) | struct tag<T const>
type tag<T volatile> (line 46) | struct tag<T volatile>
type tag<T const volatile> (line 51) | struct tag<T const volatile>
type static_ (line 56) | struct static_
type are_integral (line 59) | struct are_integral
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/count.hpp
type boost (line 17) | namespace boost { namespace accumulators
type accumulators (line 17) | namespace accumulators
type impl (line 20) | namespace impl
type count_impl (line 25) | struct count_impl
method count_impl (line 31) | count_impl(dont_care)
method result_type (line 41) | result_type result(dont_care) const
type tag (line 55) | namespace tag
type count (line 57) | struct count
type extract (line 69) | namespace extract
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/covariance.hpp
type boost (line 33) | namespace boost { namespace numeric
type numeric (line 33) | namespace numeric
type functional (line 35) | namespace functional
type std_vector_tag (line 37) | struct std_vector_tag
type outer_product_base (line 42) | struct outer_product_base
type outer_product (line 47) | struct outer_product
type outer_product<Left, Right, std_vector_tag, std_vector_tag> (line 52) | struct outer_product<Left, Right, std_vector_tag, std_vector_tag>
method result_type (line 73) | result_type
type op (line 87) | namespace op
type outer_product (line 89) | struct outer_product
type accumulators (line 101) | namespace accumulators
type impl (line 104) | namespace impl
type covariance_impl (line 122) | struct covariance_impl
method covariance_impl (line 131) | covariance_impl(Args const &args)
method result_type (line 158) | result_type result(dont_care) const
type tag (line 172) | namespace tag
type covariance (line 175) | struct covariance
type abstract_covariance (line 181) | struct abstract_covariance
type extract (line 190) | namespace extract
type feature_of<tag::covariance<VariateType, VariateTag> > (line 200) | struct feature_of<tag::covariance<VariateType, VariateTag> >
type as_weighted_feature<tag::covariance<VariateType, VariateTag> > (line 208) | struct as_weighted_feature<tag::covariance<VariateType, VariateTag> >
type feature_of<tag::weighted_covariance<VariateType, VariateTag> > (line 214) | struct feature_of<tag::weighted_covariance<VariateType, VariateTag> >
type boost (line 101) | namespace boost { namespace accumulators
type numeric (line 33) | namespace numeric
type functional (line 35) | namespace functional
type std_vector_tag (line 37) | struct std_vector_tag
type outer_product_base (line 42) | struct outer_product_base
type outer_product (line 47) | struct outer_product
type outer_product<Left, Right, std_vector_tag, std_vector_tag> (line 52) | struct outer_product<Left, Right, std_vector_tag, std_vector_tag>
method result_type (line 73) | result_type
type op (line 87) | namespace op
type outer_product (line 89) | struct outer_product
type accumulators (line 101) | namespace accumulators
type impl (line 104) | namespace impl
type covariance_impl (line 122) | struct covariance_impl
method covariance_impl (line 131) | covariance_impl(Args const &args)
method result_type (line 158) | result_type result(dont_care) const
type tag (line 172) | namespace tag
type covariance (line 175) | struct covariance
type abstract_covariance (line 181) | struct abstract_covariance
type extract (line 190) | namespace extract
type feature_of<tag::covariance<VariateType, VariateTag> > (line 200) | struct feature_of<tag::covariance<VariateType, VariateTag> >
type as_weighted_feature<tag::covariance<VariateType, VariateTag> > (line 208) | struct as_weighted_feature<tag::covariance<VariateType, VariateTag> >
type feature_of<tag::weighted_covariance<VariateType, VariateTag> > (line 214) | struct feature_of<tag::weighted_covariance<VariateType, VariateTag> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/density.hpp
type boost (line 29) | namespace boost { namespace accumulators
type accumulators (line 29) | namespace accumulators
type impl (line 41) | namespace impl
type density_impl (line 61) | struct density_impl
method density_impl (line 71) | density_impl(Args const &args)
method result_type (line 168) | result_type result(Args const &args) const
type tag (line 202) | namespace tag
type density (line 204) | struct density
type extract (line 225) | namespace extract
type as_weighted_feature<tag::density> (line 237) | struct as_weighted_feature<tag::density>
type feature_of<tag::weighted_density> (line 243) | struct feature_of<tag::weighted_density>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/error_of.hpp
type accumulators (line 17) | namespace accumulators
type impl (line 20) | namespace impl
type this_feature_has_no_error_calculation (line 25) | struct this_feature_has_no_error_calculation
type error_of_impl (line 35) | struct error_of_impl
method error_of_impl (line 45) | error_of_impl(dont_care)
method result_type (line 49) | result_type result(dont_care) const
type tag (line 60) | namespace tag
type error_of (line 63) | struct error_of
type extract (line 75) | namespace extract
type as_feature<tag::error_of<Feature> > (line 84) | struct as_feature<tag::error_of<Feature> >
type as_weighted_feature<tag::error_of<Feature> > (line 92) | struct as_weighted_feature<tag::error_of<Feature> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/error_of_mean.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 23) | namespace impl
type error_of_mean_impl (line 28) | struct error_of_mean_impl
method error_of_mean_impl (line 34) | error_of_mean_impl(dont_care) {}
method result_type (line 37) | result_type result(Args const &args) const
type tag (line 50) | namespace tag
type error_of<mean> (line 53) | struct error_of<mean>
type error_of<immediate_mean> (line 62) | struct error_of<immediate_mean>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/extended_p_square.hpp
type boost (line 30) | namespace boost { namespace accumulators
type accumulators (line 30) | namespace accumulators
type impl (line 39) | namespace impl
type extended_p_square_impl (line 69) | struct extended_p_square_impl
method extended_p_square_impl (line 85) | extended_p_square_impl(Args const &args)
method result_type (line 227) | result_type result(dont_care) const
type tag (line 252) | namespace tag
type extended_p_square (line 254) | struct extended_p_square
type extract (line 270) | namespace extract
type as_weighted_feature<tag::extended_p_square> (line 282) | struct as_weighted_feature<tag::extended_p_square>
type feature_of<tag::weighted_extended_p_square> (line 288) | struct feature_of<tag::weighted_extended_p_square>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/extended_p_square_quantile.hpp
type boost (line 40) | namespace boost { namespace accumulators
type accumulators (line 40) | namespace accumulators
type impl (line 43) | namespace impl
type extended_p_square_quantile_impl (line 57) | struct extended_p_square_quantile_impl
method extended_p_square_quantile_impl (line 74) | extended_p_square_quantile_impl(Args const &args)
method result_type (line 83) | result_type result(Args const &args) const
type tag (line 200) | namespace tag
type extended_p_square_quantile (line 202) | struct extended_p_square_quantile
type extended_p_square_quantile_quadratic (line 207) | struct extended_p_square_quantile_quadratic
type weighted_extended_p_square_quantile (line 212) | struct weighted_extended_p_square_quantile
type weighted_extended_p_square_quantile_quadratic (line 217) | struct weighted_extended_p_square_quantile_quadratic
type extract (line 228) | namespace extract
type as_feature<tag::extended_p_square_quantile(linear)> (line 248) | struct as_feature<tag::extended_p_square_quantile(linear)>
type as_feature<tag::extended_p_square_quantile(quadratic)> (line 255) | struct as_feature<tag::extended_p_square_quantile(quadratic)>
type as_feature<tag::weighted_extended_p_square_quantile(linear)> (line 262) | struct as_feature<tag::weighted_extended_p_square_quantile(linear)>
type as_feature<tag::weighted_extended_p_square_quantile(quadratic)> (line 269) | struct as_feature<tag::weighted_extended_p_square_quantile(quadratic)>
type feature_of<tag::extended_p_square_quantile> (line 278) | struct feature_of<tag::extended_p_square_quantile>
type feature_of<tag::extended_p_square_quantile_quadratic> (line 283) | struct feature_of<tag::extended_p_square_quantile_quadratic>
type as_weighted_feature<tag::extended_p_square_quantile> (line 290) | struct as_weighted_feature<tag::extended_p_square_quantile>
type feature_of<tag::weighted_extended_p_square_quantile> (line 296) | struct feature_of<tag::weighted_extended_p_square_quantile>
type as_weighted_feature<tag::extended_p_square_quantile_quadratic> (line 304) | struct as_weighted_feature<tag::extended_p_square_quantile_quadratic>
type feature_of<tag::weighted_extended_p_square_quantile_quadratic> (line 309) | struct feature_of<tag::weighted_extended_p_square_quantile_quadratic>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/kurtosis.hpp
type boost (line 21) | namespace boost { namespace accumulators
type accumulators (line 21) | namespace accumulators
type impl (line 24) | namespace impl
type kurtosis_impl (line 46) | struct kurtosis_impl
method kurtosis_impl (line 52) | kurtosis_impl(dont_care) {}
method result_type (line 55) | result_type result(Args const &args) const
type tag (line 73) | namespace tag
type kurtosis (line 75) | struct kurtosis
type extract (line 87) | namespace extract
type as_weighted_feature<tag::kurtosis> (line 99) | struct as_weighted_feature<tag::kurtosis>
type feature_of<tag::weighted_kurtosis> (line 105) | struct feature_of<tag::weighted_kurtosis>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/max.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 23) | namespace impl
type max_impl (line 28) | struct max_impl
method max_impl (line 35) | max_impl(Args const &args)
method result_type (line 46) | result_type result(dont_care) const
type tag (line 60) | namespace tag
type max (line 62) | struct max
type extract (line 74) | namespace extract
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/mean.hpp
type impl (line 24) | namespace impl
type mean_impl (line 30) | struct mean_impl
method mean_impl (line 36) | mean_impl(dont_care) {}
method result_type (line 39) | result_type result(Args const &args) const
type immediate_mean_impl (line 47) | struct immediate_mean_impl
method immediate_mean_impl (line 54) | immediate_mean_impl(Args const &args)
method result_type (line 69) | result_type result(dont_care) const
type tag (line 88) | namespace tag
type mean (line 90) | struct mean
type immediate_mean (line 97) | struct immediate_mean
type mean_of_weights (line 104) | struct mean_of_weights
type immediate_mean_of_weights (line 112) | struct immediate_mean_of_weights
type mean_of_variates (line 121) | struct mean_of_variates
type immediate_mean_of_variates (line 129) | struct immediate_mean_of_variates
type as_feature<tag::mean(immediate)> (line 166) | struct as_feature<tag::mean(immediate)>
type as_feature<tag::mean_of_weights(lazy)> (line 173) | struct as_feature<tag::mean_of_weights(lazy)>
type as_feature<tag::mean_of_weights(immediate)> (line 180) | struct as_feature<tag::mean_of_weights(immediate)>
type feature_of<tag::immediate_mean> (line 202) | struct feature_of<tag::immediate_mean>
type feature_of<tag::immediate_mean_of_weights> (line 210) | struct feature_of<tag::immediate_mean_of_weights>
type as_weighted_feature<tag::mean> (line 226) | struct as_weighted_feature<tag::mean>
type feature_of<tag::weighted_mean> (line 232) | struct feature_of<tag::weighted_mean>
type as_weighted_feature<tag::immediate_mean> (line 239) | struct as_weighted_feature<tag::immediate_mean>
type feature_of<tag::immediate_weighted_mean> (line 245) | struct feature_of<tag::immediate_weighted_mean>
type feature_of<tag::weighted_mean_of_variates<VariateType, VariateTag> > (line 258) | struct feature_of<tag::weighted_mean_of_variates<VariateType, VariateTag> >
type feature_of<tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> > (line 272) | struct feature_of<tag::immediate_weighted_mean_of_variates<VariateType, ...
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/median.hpp
type boost (line 24) | namespace boost { namespace accumulators
type accumulators (line 24) | namespace accumulators
type impl (line 27) | namespace impl
type median_impl (line 38) | struct median_impl
method median_impl (line 44) | median_impl(dont_care) {}
method result_type (line 47) | result_type result(Args const &args) const
type with_density_median_impl (line 63) | struct with_density_median_impl
method with_density_median_impl (line 73) | with_density_median_impl(Args const &args)
method result_type (line 86) | result_type result(Args const &args) const
type with_p_square_cumulative_distribution_median_impl (line 125) | struct with_p_square_cumulative_distribution_median_impl
method with_p_square_cumulative_distribution_median_impl (line 134) | with_p_square_cumulative_distribution_median_impl(dont_care)
method result_type (line 145) | result_type result(Args const &args) const
type tag (line 176) | namespace tag
type median (line 178) | struct median
type with_density_median (line 185) | struct with_density_median
type with_p_square_cumulative_distribution_median (line 192) | struct with_p_square_cumulative_distribution_median
type extract (line 206) | namespace extract
type as_feature<tag::median(with_p_square_quantile)> (line 223) | struct as_feature<tag::median(with_p_square_quantile)>
type as_feature<tag::median(with_density)> (line 230) | struct as_feature<tag::median(with_density)>
type as_feature<tag::median(with_p_square_cumulative_distribution)> (line 237) | struct as_feature<tag::median(with_p_square_cumulative_distribution)>
type feature_of<tag::with_density_median> (line 246) | struct feature_of<tag::with_density_median>
type feature_of<tag::with_p_square_cumulative_distribution_median> (line 252) | struct feature_of<tag::with_p_square_cumulative_distribution_median>
type as_weighted_feature<tag::median> (line 260) | struct as_weighted_feature<tag::median>
type feature_of<tag::weighted_median> (line 266) | struct feature_of<tag::weighted_median>
type as_weighted_feature<tag::with_density_median> (line 274) | struct as_weighted_feature<tag::with_density_median>
type feature_of<tag::with_density_weighted_median> (line 280) | struct feature_of<tag::with_density_weighted_median>
type as_weighted_feature<tag::with_p_square_cumulative_distribution_median> (line 288) | struct as_weighted_feature<tag::with_p_square_cumulative_distributio...
type feature_of<tag::with_p_square_cumulative_distribution_weighted_median> (line 294) | struct feature_of<tag::with_p_square_cumulative_distribution_weighte...
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/min.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 23) | namespace impl
type min_impl (line 28) | struct min_impl
method min_impl (line 35) | min_impl(Args const &args)
method result_type (line 46) | result_type result(dont_care) const
type tag (line 60) | namespace tag
type min (line 62) | struct min
type extract (line 74) | namespace extract
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/moment.hpp
type boost (line 23) | namespace boost { namespace numeric
type numeric (line 23) | namespace numeric
function T (line 28) | T const &pow(T const &x, mpl::int_<1>)
function T (line 36) | T pow(T const &x, mpl::int_<N>)
type accumulators (line 45) | namespace accumulators
type impl (line 48) | namespace impl
type moment_impl (line 53) | struct moment_impl
method moment_impl (line 61) | moment_impl(Args const &args)
method result_type (line 73) | result_type result(Args const &args) const
type tag (line 87) | namespace tag
type moment (line 90) | struct moment
type extract (line 102) | namespace extract
type as_weighted_feature<tag::moment<N> > (line 112) | struct as_weighted_feature<tag::moment<N> >
type feature_of<tag::weighted_moment<N> > (line 118) | struct feature_of<tag::weighted_moment<N> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/p_square_cumul_dist.hpp
type boost (line 24) | namespace boost { namespace accumulators
type accumulators (line 24) | namespace accumulators
type impl (line 33) | namespace impl
type p_square_cumulative_distribution_impl (line 54) | struct p_square_cumulative_distribution_impl
method p_square_cumulative_distribution_impl (line 64) | p_square_cumulative_distribution_impl(Args const &args)
method result_type (line 187) | result_type result(Args const &args) const
type tag (line 223) | namespace tag
type p_square_cumulative_distribution (line 225) | struct p_square_cumulative_distribution
type extract (line 238) | namespace extract
type as_weighted_feature<tag::p_square_cumulative_distribution> (line 250) | struct as_weighted_feature<tag::p_square_cumulative_distribution>
type feature_of<tag::weighted_p_square_cumulative_distribution> (line 256) | struct feature_of<tag::weighted_p_square_cumulative_distribution>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/p_square_quantile.hpp
type boost (line 26) | namespace boost { namespace accumulators
type accumulators (line 26) | namespace accumulators
type impl (line 29) | namespace impl
type p_square_quantile_impl (line 54) | struct p_square_quantile_impl
method p_square_quantile_impl (line 63) | p_square_quantile_impl(Args const &args)
method result_type (line 189) | result_type result(dont_care) const
type tag (line 207) | namespace tag
type p_square_quantile (line 209) | struct p_square_quantile
type p_square_quantile_for_median (line 216) | struct p_square_quantile_for_median
type extract (line 229) | namespace extract
type as_weighted_feature<tag::p_square_quantile> (line 244) | struct as_weighted_feature<tag::p_square_quantile>
type feature_of<tag::weighted_p_square_quantile> (line 250) | struct feature_of<tag::weighted_p_square_quantile>
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/parameters/quantile_probability.hpp
type boost (line 14) | namespace boost { namespace accumulators
type accumulators (line 14) | namespace accumulators
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/peaks_over_threshold.hpp
type boost (line 41) | namespace boost { namespace accumulators
type accumulators (line 41) | namespace accumulators
type impl (line 53) | namespace impl
type peaks_over_threshold_impl (line 125) | struct peaks_over_threshold_impl
method peaks_over_threshold_impl (line 135) | peaks_over_threshold_impl(Args const &args)
method result_type (line 159) | result_type result(Args const &args) const
type peaks_over_threshold_prob_impl (line 205) | struct peaks_over_threshold_prob_impl
method peaks_over_threshold_prob_impl (line 215) | peaks_over_threshold_prob_impl(Args const &args)
method result_type (line 230) | result_type result(Args const &args) const
type tag (line 307) | namespace tag
type peaks_over_threshold (line 310) | struct peaks_over_threshold
type peaks_over_threshold_prob (line 320) | struct peaks_over_threshold_prob
type abstract_peaks_over_threshold (line 329) | struct abstract_peaks_over_threshold
type extract (line 338) | namespace extract
type as_feature<tag::peaks_over_threshold<LeftRight>(with_threshold_value)> (line 349) | struct as_feature<tag::peaks_over_threshold<LeftRight>(with_threshol...
type as_feature<tag::peaks_over_threshold<LeftRight>(with_threshold_probability)> (line 356) | struct as_feature<tag::peaks_over_threshold<LeftRight>(with_threshol...
type feature_of<tag::peaks_over_threshold<LeftRight> > (line 362) | struct feature_of<tag::peaks_over_threshold<LeftRight> >
type feature_of<tag::peaks_over_threshold_prob<LeftRight> > (line 368) | struct feature_of<tag::peaks_over_threshold_prob<LeftRight> >
type as_weighted_feature<tag::peaks_over_threshold<LeftRight> > (line 376) | struct as_weighted_feature<tag::peaks_over_threshold<LeftRight> >
type feature_of<tag::weighted_peaks_over_threshold<LeftRight> > (line 382) | struct feature_of<tag::weighted_peaks_over_threshold<LeftRight> >
type as_weighted_feature<tag::peaks_over_threshold_prob<LeftRight> > (line 389) | struct as_weighted_feature<tag::peaks_over_threshold_prob<LeftRight> >
type feature_of<tag::weighted_peaks_over_threshold_prob<LeftRight> > (line 395) | struct feature_of<tag::weighted_peaks_over_threshold_prob<LeftRight> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/pot_quantile.hpp
type boost (line 29) | namespace boost { namespace accumulators
type accumulators (line 29) | namespace accumulators
type impl (line 32) | namespace impl
type pot_quantile_impl (line 49) | struct pot_quantile_impl
method pot_quantile_impl (line 56) | pot_quantile_impl(dont_care)
method result_type (line 62) | result_type result(Args const &args) const
type tag (line 96) | namespace tag
type pot_quantile (line 99) | struct pot_quantile
type pot_quantile_prob (line 107) | struct pot_quantile_prob
type weighted_pot_quantile (line 115) | struct weighted_pot_quantile
type weighted_pot_quantile_prob (line 123) | struct weighted_pot_quantile_prob
type as_feature<tag::pot_quantile<LeftRight>(with_threshold_value)> (line 134) | struct as_feature<tag::pot_quantile<LeftRight>(with_threshold_value)>
type as_feature<tag::pot_quantile<LeftRight>(with_threshold_probability)> (line 141) | struct as_feature<tag::pot_quantile<LeftRight>(with_threshold_probab...
type as_feature<tag::weighted_pot_quantile<LeftRight>(with_threshold_value)> (line 148) | struct as_feature<tag::weighted_pot_quantile<LeftRight>(with_thresho...
type as_feature<tag::weighted_pot_quantile<LeftRight>(with_threshold_probability)> (line 155) | struct as_feature<tag::weighted_pot_quantile<LeftRight>(with_thresho...
type feature_of<tag::pot_quantile<LeftRight> > (line 164) | struct feature_of<tag::pot_quantile<LeftRight> >
type feature_of<tag::pot_quantile_prob<LeftRight> > (line 170) | struct feature_of<tag::pot_quantile_prob<LeftRight> >
type as_weighted_feature<tag::pot_quantile<LeftRight> > (line 178) | struct as_weighted_feature<tag::pot_quantile<LeftRight> >
type feature_of<tag::weighted_pot_quantile<LeftRight> > (line 184) | struct feature_of<tag::weighted_pot_quantile<LeftRight> >
type as_weighted_feature<tag::pot_quantile_prob<LeftRight> > (line 192) | struct as_weighted_feature<tag::pot_quantile_prob<LeftRight> >
type feature_of<tag::weighted_pot_quantile_prob<LeftRight> > (line 198) | struct feature_of<tag::weighted_pot_quantile_prob<LeftRight> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/pot_tail_mean.hpp
type boost (line 31) | namespace boost { namespace accumulators
type accumulators (line 31) | namespace accumulators
type impl (line 34) | namespace impl
type pot_tail_mean_impl (line 52) | struct pot_tail_mean_impl
method pot_tail_mean_impl (line 59) | pot_tail_mean_impl(dont_care)
method result_type (line 65) | result_type result(Args const &args) const
type tag (line 102) | namespace tag
type pot_tail_mean (line 105) | struct pot_tail_mean
type pot_tail_mean_prob (line 113) | struct pot_tail_mean_prob
type weighted_pot_tail_mean (line 121) | struct weighted_pot_tail_mean
type weighted_pot_tail_mean_prob (line 129) | struct weighted_pot_tail_mean_prob
type as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_value)> (line 140) | struct as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_value)>
type as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_probability)> (line 147) | struct as_feature<tag::pot_tail_mean<LeftRight>(with_threshold_proba...
type as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_threshold_value)> (line 154) | struct as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_thresh...
type as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_threshold_probability)> (line 161) | struct as_feature<tag::weighted_pot_tail_mean<LeftRight>(with_thresh...
type feature_of<tag::pot_tail_mean<LeftRight> > (line 170) | struct feature_of<tag::pot_tail_mean<LeftRight> >
type feature_of<tag::pot_tail_mean_prob<LeftRight> > (line 176) | struct feature_of<tag::pot_tail_mean_prob<LeftRight> >
type as_weighted_feature<tag::pot_tail_mean<LeftRight> > (line 184) | struct as_weighted_feature<tag::pot_tail_mean<LeftRight> >
type feature_of<tag::weighted_pot_tail_mean<LeftRight> > (line 190) | struct feature_of<tag::weighted_pot_tail_mean<LeftRight> >
type as_weighted_feature<tag::pot_tail_mean_prob<LeftRight> > (line 198) | struct as_weighted_feature<tag::pot_tail_mean_prob<LeftRight> >
type feature_of<tag::weighted_pot_tail_mean_prob<LeftRight> > (line 204) | struct feature_of<tag::weighted_pot_tail_mean_prob<LeftRight> >
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/rolling_count.hpp
type boost (line 20) | namespace boost { namespace accumulators
type accumulators (line 20) | namespace accumulators
type impl (line 23) | namespace impl
type rolling_count_impl (line 30) | struct rolling_count_impl
method rolling_count_impl (line 35) | rolling_count_impl(dont_care)
method result_type (line 39) | result_type result(Args const &args) const
type tag (line 50) | namespace tag
type rolling_count (line 52) | struct rolling_count
type extract (line 69) | namespace extract
FILE: example/ios/Pods/boost-for-react-native/boost/accumulators/statistics/rolling_mean.hpp
type boost (line 22) | namespace boost { namespace accumulators
type accumulators (line 22) | namespace accumulators
type impl (line 24) | namespace impl
type lazy_rolling_mean_impl (line 31) | struct lazy_rolling_mean_impl
method lazy_rolling_mean_impl (line 37) | lazy_rolling_mean_impl(dont_care)
method result_type (line 42) | result_type result(Args const &args) const
type immediate_rolling_mean_impl (line 53) | struct immediate_rolling_mean_impl
method immediate_rolling_mean_impl (line 60) | immediate_rolling_mean_impl(Args const &args)
method result_type (line 80) | result_type result(Args const &) const
type tag (line 96) | namespace tag
type lazy_rolling_mean (line 98) | struct lazy_rolling_mean
type immediate_rolling_mean (line 111) | struct immediate_rolling_mean
type rolling_mean (line 125) | struct
Copy disabled (too large)
Download .json
Condensed preview — 13329 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (109,816K chars).
[
{
"path": ".gitignore",
"chars": 413,
"preview": "# OSX\n#\n.DS_Store\n\n# node.js\n#\nnode_modules/\nnpm-debug.log\nyarn-error.log\n\n# Xcode\n#\nbuild/\n*.pbxuser\n!default.pbxuser\n*"
},
{
"path": ".npmignore",
"chars": 19,
"preview": "example/\ndoc/\ndocs/"
},
{
"path": "CONTRIBUTING.md",
"chars": 8569,
"preview": "# Contributing\n\nWe want this community to be friendly and respectful to each other. Please follow it in all your interac"
},
{
"path": "LICENSE",
"chars": 1066,
"preview": "MIT License\n\nCopyright (c) 2020 Ajith A B\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "README.md",
"chars": 1345,
"preview": "# react-native-receive-sharing-intent\n\nA React Native plugin that enables React Native apps to receive sharing photos, v"
},
{
"path": "android/build.gradle",
"chars": 3465,
"preview": "buildscript {\n // Buildscript is evaluated before everything else so we can't use getExtOrDefault\n def kotlin_version "
},
{
"path": "android/gradle.properties",
"chars": 171,
"preview": "ReceiveSharingIntent_kotlinVersion=1.3.50\nReceiveSharingIntent_compileSdkVersion=29\nReceiveSharingIntent_buildToolsVersi"
},
{
"path": "android/src/main/AndroidManifest.xml",
"chars": 139,
"preview": "<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n package=\"com.reactnativereceivesharingint"
},
{
"path": "android/src/main/java/com/reactnativereceivesharingintent/FileDirectory.kt",
"chars": 5767,
"preview": "package com.reactnativereceivesharingintent;\n\nimport android.content.ContentUris\nimport android.content.Context\nimport a"
},
{
"path": "android/src/main/java/com/reactnativereceivesharingintent/ReceiveSharingIntentHelper.java",
"chars": 6995,
"preview": "package com.reactnativereceivesharingintent;\n\nimport android.app.Application;\nimport android.content.ContentResolver;\nim"
},
{
"path": "android/src/main/java/com/reactnativereceivesharingintent/ReceiveSharingIntentModule.java",
"chars": 1823,
"preview": "package com.reactnativereceivesharingintent;\n\nimport android.app.Activity;\nimport android.app.Application;\nimport androi"
},
{
"path": "android/src/main/java/com/reactnativereceivesharingintent/ReceiveSharingIntentPackage.kt",
"chars": 594,
"preview": "package com.reactnativereceivesharingintent\n\nimport com.facebook.react.ReactPackage\nimport com.facebook.react.bridge.Nat"
},
{
"path": "babel.config.js",
"chars": 77,
"preview": "module.exports = {\n presets: ['module:metro-react-native-babel-preset'],\n};\n"
},
{
"path": "docs/.gitignore",
"chars": 233,
"preview": "# Dependencies\n/node_modules\n\n# Production\n/build\n\n# Generated files\n.docusaurus\n.cache-loader\n\n# Misc\n.DS_Store\n.env.lo"
},
{
"path": "docs/README.md",
"chars": 743,
"preview": "# Website\n\nThis website is built using [Docusaurus 2](https://docusaurus.io/), a modern static website generator.\n\n## In"
},
{
"path": "docs/babel.config.js",
"chars": 89,
"preview": "module.exports = {\n presets: [require.resolve('@docusaurus/core/lib/babel/preset')],\n};\n"
},
{
"path": "docs/docs/android.md",
"chars": 3662,
"preview": "---\nsidebar_position: 2\n---\n\n# Android\n\n\n` <Project_folder>/android/app/src/main/manifest.xml `\n\n```xml\n\n<manifest xmlns"
},
{
"path": "docs/docs/author.md",
"chars": 119,
"preview": "---\nsidebar_position: 6\n---\n\n\n# Author\n[Ajith A B](https://www.linkedin.com/in/ajith-a-b-a61303197)\n\n\n### licenses\n\nMIT"
},
{
"path": "docs/docs/demo.md",
"chars": 336,
"preview": "---\nsidebar_position: 4\n---\n\n\n# Demo\n\n| Android | Ios | \n| :---: | :---: | \n| <img height=\"500\" src=\"https://raw.githubu"
},
{
"path": "docs/docs/donate.md",
"chars": 251,
"preview": "---\nsidebar_position: 5\n---\n\n# Donate\n\n\n<p><a href=\"https://www.paypal.me/ajithab\" rel=\"nofollow\"><img style={{ height: "
},
{
"path": "docs/docs/intro.md",
"chars": 1254,
"preview": "---\nsidebar_position: 1\n---\n\n\n# Installation\n\n\nimport Tabs from '@theme/Tabs';\nimport TabItem from '@theme/TabItem';\n\n<T"
},
{
"path": "docs/docs/ios.md",
"chars": 17919,
"preview": "---\nsidebar_position: 3\n---\n\n# IOS\n\n`<project_folder>/ios/<project_name>/info.plist`\n\n```xml\n<plist version=\"1.0\">\n<dict"
},
{
"path": "docs/docusaurus.config.js",
"chars": 2222,
"preview": "/** @type {import('@docusaurus/types').DocusaurusConfig} */\nmodule.exports = {\n title: 'React Native Receive Sharing In"
},
{
"path": "docs/package.json",
"chars": 1234,
"preview": "{\n \"name\": \"react-native-receive-sharing-intent\",\n \"version\": \"0.0.0\",\n \"private\": true,\n \"scripts\": {\n \"docusaur"
},
{
"path": "docs/sidebars.js",
"chars": 613,
"preview": "/**\n * Creating a sidebar enables you to:\n - create an ordered group of docs\n - render a sidebar for each doc of that gr"
},
{
"path": "docs/src/components/HomepageFeatures.js",
"chars": 1703,
"preview": "import React from 'react';\nimport clsx from 'clsx';\nimport styles from './HomepageFeatures.module.css';\n\nconst FeatureLi"
},
{
"path": "docs/src/components/HomepageFeatures.module.css",
"chars": 191,
"preview": "/* stylelint-disable docusaurus/copyright-header */\n\n.features {\n display: flex;\n align-items: center;\n padding: 2rem"
},
{
"path": "docs/src/css/custom.css",
"chars": 836,
"preview": "/* stylelint-disable docusaurus/copyright-header */\n/**\n * Any CSS included here will be global. The classic template\n *"
},
{
"path": "docs/src/pages/index.js",
"chars": 1681,
"preview": "import React, { useEffect } from 'react';\nimport clsx from 'clsx';\nimport Layout from '@theme/Layout';\nimport Link from "
},
{
"path": "docs/src/pages/index.module.css",
"chars": 418,
"preview": "/* stylelint-disable docusaurus/copyright-header */\n\n/**\n * CSS files with the .module.css suffix will be treated as CSS"
},
{
"path": "docs/src/pages/markdown-page.md",
"chars": 118,
"preview": "---\ntitle: Markdown page example\n---\n\n# Markdown page example\n\nYou don't need React to write simple standalone pages.\n"
},
{
"path": "docs/src/theme/Footer/index.tsx",
"chars": 3945,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found i"
},
{
"path": "docs/src/theme/Footer/styles.module.css",
"chars": 354,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found i"
},
{
"path": "docs/static/.nojekyll",
"chars": 0,
"preview": ""
},
{
"path": "docs/tsconfig.json",
"chars": 80,
"preview": "{\n \"extends\": \"@tsconfig/docusaurus/tsconfig.json\",\n \"include\": [\"src/\"]\n}"
},
{
"path": "example/android/app/build.gradle",
"chars": 8664,
"preview": "apply plugin: \"com.android.application\"\n\nimport com.android.build.OutputFile\n\n/**\n * The react.gradle file registers a t"
},
{
"path": "example/android/app/proguard-rules.pro",
"chars": 435,
"preview": "# Add project specific ProGuard rules here.\n# By default, the flags in this file are appended to flags specified\n# in /u"
},
{
"path": "example/android/app/src/debug/AndroidManifest.xml",
"chars": 368,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n xmlns:to"
},
{
"path": "example/android/app/src/debug/java/com/example/reactnativereceivesharingintent/ReactNativeFlipper.java",
"chars": 3291,
"preview": "/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * <p>This source code is licensed under the MIT license foun"
},
{
"path": "example/android/app/src/main/AndroidManifest.xml",
"chars": 3541,
"preview": "<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n package=\"com.example.reactnativereceivesharingint"
},
{
"path": "example/android/app/src/main/java/com/example/reactnativereceivesharingintent/MainActivity.java",
"chars": 566,
"preview": "package com.example.reactnativereceivesharingintent;\n\nimport android.content.Intent;\nimport android.util.Log;\n\nimport co"
},
{
"path": "example/android/app/src/main/java/com/example/reactnativereceivesharingintent/MainApplication.java",
"chars": 2750,
"preview": "package com.example.reactnativereceivesharingintent;\n\nimport android.app.Application;\nimport android.content.Context;\nim"
},
{
"path": "example/android/app/src/main/res/values/strings.xml",
"chars": 91,
"preview": "<resources>\n <string name=\"app_name\">ReceiveSharingIntent Example</string>\n</resources>\n"
},
{
"path": "example/android/app/src/main/res/values/styles.xml",
"chars": 246,
"preview": "<resources>\n\n <!-- Base application theme. -->\n <style name=\"AppTheme\" parent=\"Theme.AppCompat.Light.NoActionBar\">"
},
{
"path": "example/android/build.gradle",
"chars": 1003,
"preview": "// Top-level build file where you can add configuration options common to all sub-projects/modules.\n\nbuildscript {\n e"
},
{
"path": "example/android/gradle/wrapper/gradle-wrapper.properties",
"chars": 200,
"preview": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributi"
},
{
"path": "example/android/gradle.properties",
"chars": 933,
"preview": "# Project-wide Gradle settings.\n\n# IDE (e.g. Android Studio) users:\n# Gradle settings configured through the IDE *will o"
},
{
"path": "example/android/gradlew",
"chars": 5764,
"preview": "#!/usr/bin/env sh\n\n#\n# Copyright 2015 the original author or authors.\n#\n# Licensed under the Apache License, Version 2.0"
},
{
"path": "example/android/gradlew.bat",
"chars": 2952,
"preview": "@rem\n@rem Copyright 2015 the original author or authors.\n@rem\n@rem Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "example/android/settings.gradle",
"chars": 362,
"preview": "rootProject.name = 'ReceiveSharingIntentExample'\napply from: file(\"../node_modules/@react-native-community/cli-platform-"
},
{
"path": "example/app.json",
"chars": 93,
"preview": "{\n \"name\": \"ReceiveSharingIntentExample\",\n \"displayName\": \"ReceiveSharingIntent Example\"\n}\n"
},
{
"path": "example/babel.config.js",
"chars": 364,
"preview": "const path = require('path');\nconst pak = require('../package.json');\n\nmodule.exports = {\n presets: ['module:metro-reac"
},
{
"path": "example/index.tsx",
"chars": 171,
"preview": "import { AppRegistry } from 'react-native';\nimport App from './src/App';\nimport { name as appName } from './app.json';\n\n"
},
{
"path": "example/ios/File.swift",
"chars": 86,
"preview": "//\n// File.swift\n// ReceiveSharingIntentExample\n//\n\nimport Foundation\nimport Photos\n"
},
{
"path": "example/ios/Podfile",
"chars": 774,
"preview": "require_relative '../node_modules/react-native/scripts/react_native_pods'\nrequire_relative '../node_modules/@react-nativ"
},
{
"path": "example/ios/Pods/DoubleConversion/LICENSE",
"chars": 1527,
"preview": "Copyright 2006-2011, the V8 project authors. All rights reserved.\nRedistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/README",
"chars": 1489,
"preview": "http://code.google.com/p/double-conversion\n\nThis project (double-conversion) provides binary-decimal and decimal-binary\n"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/bignum-dtoa.cc",
"chars": 27312,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/bignum-dtoa.h",
"chars": 4300,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/bignum.cc",
"chars": 23075,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/bignum.h",
"chars": 5513,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/cached-powers.cc",
"chars": 8489,
"preview": "// Copyright 2006-2008 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/cached-powers.h",
"chars": 3027,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/diy-fp.cc",
"chars": 2474,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/diy-fp.h",
"chars": 3964,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/double-conversion.cc",
"chars": 30281,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/double-conversion.h",
"chars": 26197,
"preview": "// Copyright 2012 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/fast-dtoa.cc",
"chars": 31124,
"preview": "// Copyright 2012 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/fast-dtoa.h",
"chars": 4064,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/fixed-dtoa.cc",
"chars": 15102,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/fixed-dtoa.h",
"chars": 2770,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/ieee.h",
"chars": 13526,
"preview": "// Copyright 2012 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/strtod.cc",
"chars": 21038,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/strtod.h",
"chars": 2209,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/DoubleConversion/double-conversion/utils.h",
"chars": 11211,
"preview": "// Copyright 2010 the V8 project authors. All rights reserved.\n// Redistribution and use in source and binary forms, wit"
},
{
"path": "example/ios/Pods/Folly/LICENSE",
"chars": 11350,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "example/ios/Pods/Folly/README.md",
"chars": 7809,
"preview": "Folly: Facebook Open-source Library\n-----------------------------------\n\n[![Build Status](https://travis-ci.org/facebook"
},
{
"path": "example/ios/Pods/Folly/folly/AtomicHashArray-inl.h",
"chars": 16166,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/AtomicHashArray.h",
"chars": 14449,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/AtomicHashMap-inl.h",
"chars": 18002,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/AtomicHashMap.h",
"chars": 16896,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/AtomicIntrusiveLinkedList.h",
"chars": 5026,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/AtomicLinkedList.h",
"chars": 3118,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/AtomicUnorderedMap.h",
"chars": 18303,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Benchmark.h",
"chars": 23116,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Bits.h",
"chars": 656,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/CPortability.h",
"chars": 7334,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/CachelinePadded.h",
"chars": 2110,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/CancellationToken-inl.h",
"chars": 10486,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/CancellationToken.h",
"chars": 11579,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Chrono.h",
"chars": 6448,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ClockGettimeWrappers.h",
"chars": 870,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ConcurrentBitSet.h",
"chars": 4474,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ConcurrentSkipList-inl.h",
"chars": 10347,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ConcurrentSkipList.h",
"chars": 26884,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ConstexprMath.h",
"chars": 13337,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Conv.cpp",
"chars": 25814,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Conv.h",
"chars": 52987,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/CppAttributes.h",
"chars": 3141,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/CpuId.h",
"chars": 6792,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/DefaultKeepAliveExecutor.h",
"chars": 4307,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Demangle.cpp",
"chars": 3232,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Demangle.h",
"chars": 2306,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/DiscriminatedPtr.h",
"chars": 7103,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/DynamicConverter.h",
"chars": 11392,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Exception.h",
"chars": 4712,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ExceptionString.h",
"chars": 1814,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ExceptionWrapper-inl.h",
"chars": 21185,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ExceptionWrapper.h",
"chars": 27237,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Executor.h",
"chars": 9695,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Expected.h",
"chars": 47676,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/FBString.h",
"chars": 83884,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/FBVector.h",
"chars": 53311,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/File.h",
"chars": 4022,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/FileUtil.cpp",
"chars": 7288,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/FileUtil.h",
"chars": 9254,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Fingerprint.h",
"chars": 8279,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/FixedString.h",
"chars": 102726,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Format-inl.h",
"chars": 33339,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Format.cpp",
"chars": 12103,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Format.h",
"chars": 15217,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/FormatArg.h",
"chars": 6347,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/FormatTraits.h",
"chars": 2003,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Function.h",
"chars": 37919,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/GLog.h",
"chars": 2831,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/GroupVarint.h",
"chars": 18824,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Hash.h",
"chars": 672,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/IPAddress.h",
"chars": 17494,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/IPAddressException.h",
"chars": 2613,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/IPAddressV4.h",
"chars": 9687,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/IPAddressV6.h",
"chars": 12350,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Indestructible.h",
"chars": 5621,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/IndexedMemPool.h",
"chars": 19372,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/IntrusiveList.h",
"chars": 4042,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Lazy.h",
"chars": 4142,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Likely.h",
"chars": 1584,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/LockTraits.h",
"chars": 20443,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/MPMCPipeline.h",
"chars": 8749,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/MPMCQueue.h",
"chars": 55699,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/MacAddress.h",
"chars": 6643,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/MapUtil.h",
"chars": 9895,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Math.h",
"chars": 8387,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Memory.h",
"chars": 23341,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/MicroLock.h",
"chars": 8007,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/MicroSpinLock.h",
"chars": 676,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/MoveWrapper.h",
"chars": 2413,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Optional.h",
"chars": 18276,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Overload.h",
"chars": 2052,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/PackedSyncPtr.h",
"chars": 5071,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Padded.h",
"chars": 16811,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Poly-inl.h",
"chars": 7448,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Poly.h",
"chars": 39218,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/PolyException.h",
"chars": 1268,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Portability.h",
"chars": 14456,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Preprocessor.h",
"chars": 5233,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ProducerConsumerQueue.h",
"chars": 5478,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/RWSpinLock.h",
"chars": 673,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Random-inl.h",
"chars": 2726,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Random.h",
"chars": 9977,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Range.h",
"chars": 46273,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Replaceable.h",
"chars": 23118,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ScopeGuard.cpp",
"chars": 954,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ScopeGuard.h",
"chars": 9086,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/SharedMutex.h",
"chars": 64759,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Singleton-inl.h",
"chars": 8513,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Singleton.h",
"chars": 26585,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/SingletonThreadLocal.h",
"chars": 8803,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/SocketAddress.h",
"chars": 18886,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/SpinLock.h",
"chars": 2282,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/String-inl.h",
"chars": 19261,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/String.cpp",
"chars": 22738,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/String.h",
"chars": 20615,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Subprocess.h",
"chars": 35891,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Synchronized.h",
"chars": 64635,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/SynchronizedPtr.h",
"chars": 3863,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ThreadCachedInt.h",
"chars": 5554,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/ThreadLocal.h",
"chars": 14520,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/TimeoutQueue.h",
"chars": 3862,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/TokenBucket.h",
"chars": 16504,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Traits.h",
"chars": 27929,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Try-inl.h",
"chars": 9167,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Try.h",
"chars": 19052,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/UTF8String.h",
"chars": 1475,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Unicode.cpp",
"chars": 4052,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Unicode.h",
"chars": 1248,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Unit.h",
"chars": 2093,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Uri-inl.h",
"chars": 2343,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Uri.h",
"chars": 4200,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Utility.h",
"chars": 11447,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/Varint.h",
"chars": 6009,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/VirtualExecutor.h",
"chars": 2384,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/Access.h",
"chars": 2155,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/Array.h",
"chars": 2449,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/BitIterator.h",
"chars": 5771,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/Enumerate.h",
"chars": 4514,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/EvictingCacheMap.h",
"chars": 18890,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/F14Map-fwd.h",
"chars": 3139,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/F14Map.h",
"chars": 42809,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/F14Set-fwd.h",
"chars": 2667,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
},
{
"path": "example/ios/Pods/Folly/folly/container/F14Set.h",
"chars": 36822,
"preview": "/*\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Licens"
}
]
// ... and 13129 more files (download for full content)
About this extraction
This page contains the full source code of the ajith-ab/react-native-receive-sharing-intent GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 13329 files (129.0 MB), approximately 27.2M tokens, and a symbol index with 144554 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.