Showing preview only (2,428K chars total). Download the full file or copy to clipboard to get everything.
Repository: JetBrains/UnrealLink
Branch: main
Commit: b562e254780f
Files: 490
Total size: 2.2 MB
Directory structure:
gitextract_ql_wvwqe/
├── .editorconfig
├── .gitattributes
├── .github/
│ └── workflows/
│ └── build.yml
├── .gitignore
├── .run/
│ ├── Debug backend.run.xml
│ └── UnrealLink [runIde].run.xml
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── License.txt
├── README.md
├── SETUP.md
├── SdkBasedPluginEmbedding.Root
├── SubplatformsCollection.Root
├── UnrealLink.sln
├── build.gradle.kts
├── gradle/
│ └── wrapper/
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
├── protocol/
│ ├── build.gradle.kts
│ └── src/
│ └── main/
│ └── kotlin/
│ └── model/
│ ├── editorPlugin/
│ │ ├── LiveCodingModel.kt
│ │ └── RdEditorModel.kt
│ ├── lib/
│ │ └── ue4/
│ │ └── UE4Library.kt
│ └── rider/
│ └── RdRiderModel.kt
├── settings.gradle.kts
├── setup_unreal_plugin.cmd
├── src/
│ ├── SubplatformsCollection.Root
│ ├── cpp/
│ │ ├── BuildScript/
│ │ │ └── GenerateRiderLinkZip.cs
│ │ ├── RiderLink/
│ │ │ ├── RiderLink.uplugin.template
│ │ │ └── Source/
│ │ │ ├── RD/
│ │ │ │ ├── RD.Build.cs
│ │ │ │ ├── RD.cpp
│ │ │ │ ├── RD.h
│ │ │ │ ├── src/
│ │ │ │ │ ├── rd_core_cpp/
│ │ │ │ │ │ ├── rd_core_export.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ └── main/
│ │ │ │ │ │ ├── lifetime/
│ │ │ │ │ │ │ ├── Lifetime.cpp
│ │ │ │ │ │ │ ├── Lifetime.h
│ │ │ │ │ │ │ ├── LifetimeDefinition.cpp
│ │ │ │ │ │ │ ├── LifetimeDefinition.h
│ │ │ │ │ │ │ ├── LifetimeImpl.cpp
│ │ │ │ │ │ │ ├── LifetimeImpl.h
│ │ │ │ │ │ │ ├── SequentialLifetimes.cpp
│ │ │ │ │ │ │ └── SequentialLifetimes.h
│ │ │ │ │ │ ├── reactive/
│ │ │ │ │ │ │ ├── Property.h
│ │ │ │ │ │ │ ├── ViewableList.h
│ │ │ │ │ │ │ ├── ViewableMap.h
│ │ │ │ │ │ │ ├── ViewableSet.h
│ │ │ │ │ │ │ └── base/
│ │ │ │ │ │ │ ├── IProperty.h
│ │ │ │ │ │ │ ├── IPropertyBase.h
│ │ │ │ │ │ │ ├── IViewableList.h
│ │ │ │ │ │ │ ├── IViewableMap.h
│ │ │ │ │ │ │ ├── IViewableSet.h
│ │ │ │ │ │ │ ├── SignalCookie.cpp
│ │ │ │ │ │ │ ├── SignalCookie.h
│ │ │ │ │ │ │ ├── SignalX.h
│ │ │ │ │ │ │ ├── interfaces.h
│ │ │ │ │ │ │ └── viewable_collections.h
│ │ │ │ │ │ ├── std/
│ │ │ │ │ │ │ ├── allocator.h
│ │ │ │ │ │ │ ├── hash.h
│ │ │ │ │ │ │ ├── list.h
│ │ │ │ │ │ │ ├── to_string.h
│ │ │ │ │ │ │ ├── unordered_map.h
│ │ │ │ │ │ │ └── unordered_set.h
│ │ │ │ │ │ ├── types/
│ │ │ │ │ │ │ ├── DateTime.cpp
│ │ │ │ │ │ │ ├── DateTime.h
│ │ │ │ │ │ │ ├── Void.h
│ │ │ │ │ │ │ └── wrapper.h
│ │ │ │ │ │ └── util/
│ │ │ │ │ │ ├── core_traits.h
│ │ │ │ │ │ ├── core_util.h
│ │ │ │ │ │ ├── enum.h
│ │ │ │ │ │ ├── erase_if.h
│ │ │ │ │ │ ├── gen_util.h
│ │ │ │ │ │ ├── overloaded.h
│ │ │ │ │ │ └── shared_function.h
│ │ │ │ │ ├── rd_framework_cpp/
│ │ │ │ │ │ ├── rd_framework_export.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ └── main/
│ │ │ │ │ │ ├── base/
│ │ │ │ │ │ │ ├── IProtocol.cpp
│ │ │ │ │ │ │ ├── IProtocol.h
│ │ │ │ │ │ │ ├── IRdBindable.h
│ │ │ │ │ │ │ ├── IRdDynamic.h
│ │ │ │ │ │ │ ├── IRdReactive.h
│ │ │ │ │ │ │ ├── IRdWireable.cpp
│ │ │ │ │ │ │ ├── IRdWireable.h
│ │ │ │ │ │ │ ├── ISerializersOwner.cpp
│ │ │ │ │ │ │ ├── ISerializersOwner.h
│ │ │ │ │ │ │ ├── IUnknownInstance.cpp
│ │ │ │ │ │ │ ├── IUnknownInstance.h
│ │ │ │ │ │ │ ├── IWire.h
│ │ │ │ │ │ │ ├── RdBindableBase.cpp
│ │ │ │ │ │ │ ├── RdBindableBase.h
│ │ │ │ │ │ │ ├── RdPropertyBase.h
│ │ │ │ │ │ │ ├── RdReactiveBase.cpp
│ │ │ │ │ │ │ ├── RdReactiveBase.h
│ │ │ │ │ │ │ ├── WireBase.cpp
│ │ │ │ │ │ │ └── WireBase.h
│ │ │ │ │ │ ├── ext/
│ │ │ │ │ │ │ ├── ExtWire.cpp
│ │ │ │ │ │ │ ├── ExtWire.h
│ │ │ │ │ │ │ ├── RdExtBase.cpp
│ │ │ │ │ │ │ └── RdExtBase.h
│ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ ├── RName.cpp
│ │ │ │ │ │ │ ├── RName.h
│ │ │ │ │ │ │ ├── RdList.h
│ │ │ │ │ │ │ ├── RdMap.h
│ │ │ │ │ │ │ ├── RdProperty.h
│ │ │ │ │ │ │ ├── RdSet.h
│ │ │ │ │ │ │ └── RdSignal.h
│ │ │ │ │ │ ├── intern/
│ │ │ │ │ │ │ ├── InternRoot.cpp
│ │ │ │ │ │ │ ├── InternRoot.h
│ │ │ │ │ │ │ ├── InternScheduler.cpp
│ │ │ │ │ │ │ └── InternScheduler.h
│ │ │ │ │ │ ├── protocol/
│ │ │ │ │ │ │ ├── Buffer.cpp
│ │ │ │ │ │ │ ├── Buffer.h
│ │ │ │ │ │ │ ├── Identities.cpp
│ │ │ │ │ │ │ ├── Identities.h
│ │ │ │ │ │ │ ├── MessageBroker.cpp
│ │ │ │ │ │ │ ├── MessageBroker.h
│ │ │ │ │ │ │ ├── Protocol.cpp
│ │ │ │ │ │ │ ├── Protocol.h
│ │ │ │ │ │ │ ├── RdId.cpp
│ │ │ │ │ │ │ └── RdId.h
│ │ │ │ │ │ ├── scheduler/
│ │ │ │ │ │ │ ├── SimpleScheduler.cpp
│ │ │ │ │ │ │ ├── SimpleScheduler.h
│ │ │ │ │ │ │ ├── SingleThreadScheduler.cpp
│ │ │ │ │ │ │ ├── SingleThreadScheduler.h
│ │ │ │ │ │ │ ├── SynchronousScheduler.cpp
│ │ │ │ │ │ │ ├── SynchronousScheduler.h
│ │ │ │ │ │ │ └── base/
│ │ │ │ │ │ │ ├── IScheduler.cpp
│ │ │ │ │ │ │ ├── IScheduler.h
│ │ │ │ │ │ │ ├── SingleThreadSchedulerBase.cpp
│ │ │ │ │ │ │ └── SingleThreadSchedulerBase.h
│ │ │ │ │ │ ├── serialization/
│ │ │ │ │ │ │ ├── AbstractPolymorphic.h
│ │ │ │ │ │ │ ├── ArraySerializer.h
│ │ │ │ │ │ │ ├── DefaultAbstractDeclaration.cpp
│ │ │ │ │ │ │ ├── DefaultAbstractDeclaration.h
│ │ │ │ │ │ │ ├── ISerializable.cpp
│ │ │ │ │ │ │ ├── ISerializable.h
│ │ │ │ │ │ │ ├── InternedAnySerializer.h
│ │ │ │ │ │ │ ├── InternedSerializer.h
│ │ │ │ │ │ │ ├── NullableSerializer.h
│ │ │ │ │ │ │ ├── Polymorphic.cpp
│ │ │ │ │ │ │ ├── Polymorphic.h
│ │ │ │ │ │ │ ├── RdAny.cpp
│ │ │ │ │ │ │ ├── RdAny.h
│ │ │ │ │ │ │ ├── SerializationCtx.cpp
│ │ │ │ │ │ │ ├── SerializationCtx.h
│ │ │ │ │ │ │ ├── Serializers.cpp
│ │ │ │ │ │ │ └── Serializers.h
│ │ │ │ │ │ ├── task/
│ │ │ │ │ │ │ ├── RdCall.h
│ │ │ │ │ │ │ ├── RdEndpoint.h
│ │ │ │ │ │ │ ├── RdSymmetricCall.h
│ │ │ │ │ │ │ ├── RdTask.h
│ │ │ │ │ │ │ ├── RdTaskImpl.h
│ │ │ │ │ │ │ ├── RdTaskResult.h
│ │ │ │ │ │ │ ├── WiredRdTask.h
│ │ │ │ │ │ │ └── WiredRdTaskImpl.h
│ │ │ │ │ │ ├── util/
│ │ │ │ │ │ │ ├── framework_traits.h
│ │ │ │ │ │ │ ├── guards.h
│ │ │ │ │ │ │ ├── hashing.cpp
│ │ │ │ │ │ │ ├── hashing.h
│ │ │ │ │ │ │ ├── thread_util.cpp
│ │ │ │ │ │ │ └── thread_util.h
│ │ │ │ │ │ └── wire/
│ │ │ │ │ │ ├── ByteBufferAsyncProcessor.cpp
│ │ │ │ │ │ ├── ByteBufferAsyncProcessor.h
│ │ │ │ │ │ ├── PkgInputStream.cpp
│ │ │ │ │ │ ├── PkgInputStream.h
│ │ │ │ │ │ ├── PumpScheduler.cpp
│ │ │ │ │ │ ├── PumpScheduler.h
│ │ │ │ │ │ ├── SocketWire.cpp
│ │ │ │ │ │ ├── SocketWire.h
│ │ │ │ │ │ ├── WireUtil.cpp
│ │ │ │ │ │ └── WireUtil.h
│ │ │ │ │ └── rd_gen_cpp/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── RdTextBuffer.cpp
│ │ │ │ │ └── RdTextBuffer.h
│ │ │ │ └── thirdparty/
│ │ │ │ ├── CTPL/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── include/
│ │ │ │ │ └── ctpl_stl.h
│ │ │ │ ├── clsocket/
│ │ │ │ │ ├── README
│ │ │ │ │ └── src/
│ │ │ │ │ ├── ActiveSocket.cpp
│ │ │ │ │ ├── ActiveSocket.h
│ │ │ │ │ ├── Host.h
│ │ │ │ │ ├── PassiveSocket.cpp
│ │ │ │ │ ├── PassiveSocket.h
│ │ │ │ │ ├── SimpleSocket.cpp
│ │ │ │ │ ├── SimpleSocket.h
│ │ │ │ │ └── StatTimer.h
│ │ │ │ ├── countdownlatch/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── countdownlatch.cpp
│ │ │ │ │ └── countdownlatch.hpp
│ │ │ │ ├── optional/
│ │ │ │ │ ├── COPYING
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── tl/
│ │ │ │ │ └── optional.hpp
│ │ │ │ ├── ordered-map/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── include/
│ │ │ │ │ └── tsl/
│ │ │ │ │ ├── ordered_hash.h
│ │ │ │ │ ├── ordered_map.h
│ │ │ │ │ └── ordered_set.h
│ │ │ │ ├── spdlog/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── cmake/
│ │ │ │ │ │ ├── ide.cmake
│ │ │ │ │ │ ├── spdlog.pc.in
│ │ │ │ │ │ ├── spdlogCPack.cmake
│ │ │ │ │ │ ├── spdlogConfig.cmake.in
│ │ │ │ │ │ ├── utils.cmake
│ │ │ │ │ │ └── version.rc.in
│ │ │ │ │ ├── include/
│ │ │ │ │ │ └── spdlog/
│ │ │ │ │ │ ├── async.h
│ │ │ │ │ │ ├── async_logger-inl.h
│ │ │ │ │ │ ├── async_logger.h
│ │ │ │ │ │ ├── cfg/
│ │ │ │ │ │ │ ├── argv.h
│ │ │ │ │ │ │ ├── env.h
│ │ │ │ │ │ │ ├── helpers-inl.h
│ │ │ │ │ │ │ ├── helpers.h
│ │ │ │ │ │ │ └── log_levels.h
│ │ │ │ │ │ ├── common-inl.h
│ │ │ │ │ │ ├── common.h
│ │ │ │ │ │ ├── details/
│ │ │ │ │ │ │ ├── backtracer-inl.h
│ │ │ │ │ │ │ ├── backtracer.h
│ │ │ │ │ │ │ ├── circular_q.h
│ │ │ │ │ │ │ ├── console_globals.h
│ │ │ │ │ │ │ ├── file_helper-inl.h
│ │ │ │ │ │ │ ├── file_helper.h
│ │ │ │ │ │ │ ├── fmt_helper.h
│ │ │ │ │ │ │ ├── log_msg-inl.h
│ │ │ │ │ │ │ ├── log_msg.h
│ │ │ │ │ │ │ ├── log_msg_buffer-inl.h
│ │ │ │ │ │ │ ├── log_msg_buffer.h
│ │ │ │ │ │ │ ├── mpmc_blocking_q.h
│ │ │ │ │ │ │ ├── null_mutex.h
│ │ │ │ │ │ │ ├── os-inl.h
│ │ │ │ │ │ │ ├── os.h
│ │ │ │ │ │ │ ├── periodic_worker-inl.h
│ │ │ │ │ │ │ ├── periodic_worker.h
│ │ │ │ │ │ │ ├── registry-inl.h
│ │ │ │ │ │ │ ├── registry.h
│ │ │ │ │ │ │ ├── synchronous_factory.h
│ │ │ │ │ │ │ ├── tcp_client-windows.h
│ │ │ │ │ │ │ ├── tcp_client.h
│ │ │ │ │ │ │ ├── thread_pool-inl.h
│ │ │ │ │ │ │ ├── thread_pool.h
│ │ │ │ │ │ │ ├── udp_client-windows.h
│ │ │ │ │ │ │ ├── udp_client.h
│ │ │ │ │ │ │ └── windows_include.h
│ │ │ │ │ │ ├── fmt/
│ │ │ │ │ │ │ ├── bin_to_hex.h
│ │ │ │ │ │ │ ├── bundled/
│ │ │ │ │ │ │ │ ├── LICENSE.rst
│ │ │ │ │ │ │ │ ├── args.h
│ │ │ │ │ │ │ │ ├── chrono.h
│ │ │ │ │ │ │ │ ├── color.h
│ │ │ │ │ │ │ │ ├── compile.h
│ │ │ │ │ │ │ │ ├── core.h
│ │ │ │ │ │ │ │ ├── fmt.license.rst
│ │ │ │ │ │ │ │ ├── format-inl.h
│ │ │ │ │ │ │ │ ├── format.h
│ │ │ │ │ │ │ │ ├── locale.h
│ │ │ │ │ │ │ │ ├── os.h
│ │ │ │ │ │ │ │ ├── ostream.h
│ │ │ │ │ │ │ │ ├── posix.h
│ │ │ │ │ │ │ │ ├── printf.h
│ │ │ │ │ │ │ │ ├── ranges.h
│ │ │ │ │ │ │ │ └── xchar.h
│ │ │ │ │ │ │ ├── chrono.h
│ │ │ │ │ │ │ ├── compile.h
│ │ │ │ │ │ │ ├── fmt.h
│ │ │ │ │ │ │ ├── ostr.h
│ │ │ │ │ │ │ ├── ranges.h
│ │ │ │ │ │ │ └── xchar.h
│ │ │ │ │ │ ├── formatter.h
│ │ │ │ │ │ ├── fwd.h
│ │ │ │ │ │ ├── logger-inl.h
│ │ │ │ │ │ ├── logger.h
│ │ │ │ │ │ ├── pattern_formatter-inl.h
│ │ │ │ │ │ ├── pattern_formatter.h
│ │ │ │ │ │ ├── sinks/
│ │ │ │ │ │ │ ├── android_sink.h
│ │ │ │ │ │ │ ├── ansicolor_sink-inl.h
│ │ │ │ │ │ │ ├── ansicolor_sink.h
│ │ │ │ │ │ │ ├── base_sink-inl.h
│ │ │ │ │ │ │ ├── base_sink.h
│ │ │ │ │ │ │ ├── basic_file_sink-inl.h
│ │ │ │ │ │ │ ├── basic_file_sink.h
│ │ │ │ │ │ │ ├── daily_file_sink.h
│ │ │ │ │ │ │ ├── dist_sink.h
│ │ │ │ │ │ │ ├── dup_filter_sink.h
│ │ │ │ │ │ │ ├── hourly_file_sink.h
│ │ │ │ │ │ │ ├── mongo_sink.h
│ │ │ │ │ │ │ ├── msvc_sink.h
│ │ │ │ │ │ │ ├── null_sink.h
│ │ │ │ │ │ │ ├── ostream_sink.h
│ │ │ │ │ │ │ ├── qt_sinks.h
│ │ │ │ │ │ │ ├── ringbuffer_sink.h
│ │ │ │ │ │ │ ├── rotating_file_sink-inl.h
│ │ │ │ │ │ │ ├── rotating_file_sink.h
│ │ │ │ │ │ │ ├── sink-inl.h
│ │ │ │ │ │ │ ├── sink.h
│ │ │ │ │ │ │ ├── stdout_color_sinks-inl.h
│ │ │ │ │ │ │ ├── stdout_color_sinks.h
│ │ │ │ │ │ │ ├── stdout_sinks-inl.h
│ │ │ │ │ │ │ ├── stdout_sinks.h
│ │ │ │ │ │ │ ├── syslog_sink.h
│ │ │ │ │ │ │ ├── systemd_sink.h
│ │ │ │ │ │ │ ├── tcp_sink.h
│ │ │ │ │ │ │ ├── udp_sink.h
│ │ │ │ │ │ │ ├── win_eventlog_sink.h
│ │ │ │ │ │ │ ├── wincolor_sink-inl.h
│ │ │ │ │ │ │ └── wincolor_sink.h
│ │ │ │ │ │ ├── spdlog-inl.h
│ │ │ │ │ │ ├── spdlog.h
│ │ │ │ │ │ ├── stopwatch.h
│ │ │ │ │ │ ├── tweakme.h
│ │ │ │ │ │ └── version.h
│ │ │ │ │ ├── scripts/
│ │ │ │ │ │ ├── extract_version.py
│ │ │ │ │ │ └── format.sh
│ │ │ │ │ └── src/
│ │ │ │ │ ├── async.cpp
│ │ │ │ │ ├── cfg.cpp
│ │ │ │ │ ├── color_sinks.cpp
│ │ │ │ │ ├── file_sinks.cpp
│ │ │ │ │ ├── fmt.cpp
│ │ │ │ │ ├── spdlog.cpp
│ │ │ │ │ └── stdout_sinks.cpp
│ │ │ │ ├── string-view-lite/
│ │ │ │ │ ├── LICENSE.txt
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── cmake/
│ │ │ │ │ │ └── string_view-lite-config.cmake.in
│ │ │ │ │ └── include/
│ │ │ │ │ └── nonstd/
│ │ │ │ │ └── string_view.hpp
│ │ │ │ ├── thirdparty.cpp
│ │ │ │ ├── thirdparty.hpp
│ │ │ │ ├── utf-cpp/
│ │ │ │ │ ├── LICENSE.md
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── include/
│ │ │ │ │ └── ww898/
│ │ │ │ │ ├── cp_utf16.hpp
│ │ │ │ │ ├── cp_utf32.hpp
│ │ │ │ │ ├── cp_utf8.hpp
│ │ │ │ │ ├── cp_utfw.hpp
│ │ │ │ │ ├── utf_config.hpp
│ │ │ │ │ ├── utf_converters.hpp
│ │ │ │ │ ├── utf_selector.hpp
│ │ │ │ │ └── utf_sizes.hpp
│ │ │ │ └── variant/
│ │ │ │ ├── LICENSE.md
│ │ │ │ ├── README.md
│ │ │ │ ├── cmake/
│ │ │ │ │ └── mpark_variant-config.cmake.in
│ │ │ │ └── include/
│ │ │ │ └── mpark/
│ │ │ │ ├── config.hpp
│ │ │ │ ├── in_place.hpp
│ │ │ │ ├── lib.hpp
│ │ │ │ └── variant.hpp
│ │ │ ├── RiderBlueprint/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── BlueprintProvider.cpp
│ │ │ │ │ └── RiderBlueprint.cpp
│ │ │ │ ├── Public/
│ │ │ │ │ ├── BlueprintProvider.hpp
│ │ │ │ │ └── RiderBlueprint.hpp
│ │ │ │ └── RiderBlueprint.Build.cs
│ │ │ ├── RiderDebuggerSupport/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── BlueprintStackGetter.cpp
│ │ │ │ │ ├── DebugLogger.cpp
│ │ │ │ │ ├── DebugLogger.h
│ │ │ │ │ ├── RiderDebuggerSupport.cpp
│ │ │ │ │ ├── RiderDebuggerSupport.h
│ │ │ │ │ ├── UnrealFunctions.cpp
│ │ │ │ │ ├── UnrealFunctions.h
│ │ │ │ │ ├── WideStringWrapper.cpp
│ │ │ │ │ └── WideStringWrapper.h
│ │ │ │ └── RiderDebuggerSupport.Build.cs
│ │ │ ├── RiderGameControl/
│ │ │ │ ├── Private/
│ │ │ │ │ └── RiderGameControl.cpp
│ │ │ │ ├── Public/
│ │ │ │ │ └── RiderGameControl.hpp
│ │ │ │ └── RiderGameControl.Build.cs
│ │ │ ├── RiderLC/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── RiderLC.cpp
│ │ │ │ │ └── RiderLC.hpp
│ │ │ │ └── RiderLC.Build.cs
│ │ │ ├── RiderLink/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── ProtocolFactory.cpp
│ │ │ │ │ ├── ProtocolFactory.h
│ │ │ │ │ ├── RiderLink.cpp
│ │ │ │ │ ├── RiderLink.hpp
│ │ │ │ │ └── UE4TypesMarshallers.cpp
│ │ │ │ ├── Public/
│ │ │ │ │ ├── IRiderLink.hpp
│ │ │ │ │ └── UE4TypesMarshallers.h
│ │ │ │ └── RiderLink.Build.cs
│ │ │ ├── RiderLogging/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── RiderLogging.cpp
│ │ │ │ │ ├── RiderLogging.hpp
│ │ │ │ │ ├── RiderOutputDevice.cpp
│ │ │ │ │ └── RiderOutputDevice.hpp
│ │ │ │ └── RiderLogging.Build.cs
│ │ │ └── RiderShaderInfo/
│ │ │ ├── RiderShaderInfo.Build.cs
│ │ │ ├── RiderShaderInfo.cpp
│ │ │ └── RiderShaderInfo.h
│ │ ├── Subplatform.Root
│ │ └── Subplatform.Snk
│ ├── dotnet/
│ │ ├── BuildScript/
│ │ │ └── DefineUnrealLinkConstants.cs
│ │ ├── Directory.Build.props
│ │ ├── PackagesLock.targets
│ │ ├── Plugin.props
│ │ ├── RiderPlugin.UnrealLink/
│ │ │ ├── BuildScript/
│ │ │ │ └── UnrealLinkInRiderProduct.cs
│ │ │ ├── EditorNavigator.cs
│ │ │ ├── Install/
│ │ │ │ └── AdvertiseRiderBundledPlugin.cs
│ │ │ ├── LinkResolver.cs
│ │ │ ├── PluginInstaller/
│ │ │ │ ├── PluginPathsProvider.cs
│ │ │ │ ├── UnrealPluginDetector.cs
│ │ │ │ ├── UnrealPluginInstallInfo.cs
│ │ │ │ ├── UnrealPluginInstaller.cs
│ │ │ │ └── UnrealProjectsRefresher.cs
│ │ │ ├── Resources/
│ │ │ │ ├── Strings.Designer.cs
│ │ │ │ └── Strings.resx
│ │ │ ├── RiderBackendToUnrealEditor.cs
│ │ │ ├── RiderPlugin.UnrealLink.csproj
│ │ │ ├── Settings/
│ │ │ │ └── UnrealLinkOptionsPage.cs
│ │ │ ├── UnrealEngineAssetsNavigationProvider.cs
│ │ │ ├── UnrealHost.cs
│ │ │ ├── UnrealLiveCodingBuildRunner.cs
│ │ │ ├── Utils/
│ │ │ │ ├── CmdUtils.cs
│ │ │ │ ├── FsUtils.cs
│ │ │ │ └── ModelUtils.cs
│ │ │ └── ZoneMarker.cs
│ │ ├── Subplatform.Root
│ │ ├── Subplatform.Snk
│ │ └── Versions.props
│ └── rider/
│ ├── main/
│ │ ├── kotlin/
│ │ │ ├── com/
│ │ │ │ └── jetbrains/
│ │ │ │ └── rider/
│ │ │ │ ├── UnrealLinkBundle.kt
│ │ │ │ ├── plugins/
│ │ │ │ │ └── unreal/
│ │ │ │ │ ├── RiderLinkInstallService.kt
│ │ │ │ │ ├── UE4LibraryStartUpSerializerRegistrar.kt
│ │ │ │ │ ├── UnrealHost.kt
│ │ │ │ │ ├── UnrealLinkSettings.kt
│ │ │ │ │ ├── UnrealPluginUsagesCollector.kt
│ │ │ │ │ ├── actions/
│ │ │ │ │ │ ├── ActionsUtils.kt
│ │ │ │ │ │ ├── CancelRiderLinkInstallAction.kt
│ │ │ │ │ │ ├── EnableAutoUpdatePlugin.kt
│ │ │ │ │ │ ├── FilterCheckboxAction.kt
│ │ │ │ │ │ ├── HotReloadBuildAction.kt
│ │ │ │ │ │ ├── HotReloadBuildModeProvider.kt
│ │ │ │ │ │ ├── InstallActions.kt
│ │ │ │ │ │ ├── PlayActions.kt
│ │ │ │ │ │ ├── PlaySettingsActions.kt
│ │ │ │ │ │ └── UnrealHostOperations.kt
│ │ │ │ │ ├── debugger/
│ │ │ │ │ │ ├── BlueprintCallstackFrameCompatibilityMatcher.kt
│ │ │ │ │ │ ├── BlueprintCallstackFrameMatchResult.kt
│ │ │ │ │ │ ├── BlueprintExecutionStack.kt
│ │ │ │ │ │ ├── BlueprintStackFrameContainer.kt
│ │ │ │ │ │ ├── BlueprintStackTransformer.kt
│ │ │ │ │ │ ├── UnrealDebugProcessExtension.kt
│ │ │ │ │ │ ├── UnrealDebuggerLogger.kt
│ │ │ │ │ │ ├── actions/
│ │ │ │ │ │ │ ├── FramesPopupGroup.kt
│ │ │ │ │ │ │ ├── ShowBlueprintFunctionsAction.kt
│ │ │ │ │ │ │ ├── ShowLibraryFramesAction.kt
│ │ │ │ │ │ │ ├── ShowUnrealFramesAction.kt
│ │ │ │ │ │ │ └── UnrealToggleBaseAction.kt
│ │ │ │ │ │ └── frames/
│ │ │ │ │ │ ├── BlueprintFrame.kt
│ │ │ │ │ │ ├── BlueprintFrameMessages.kt
│ │ │ │ │ │ ├── StubBlueprintFrame.kt
│ │ │ │ │ │ ├── UnrealExternalCodeFrame.kt
│ │ │ │ │ │ └── UnrealFrameBase.kt
│ │ │ │ │ ├── filters/
│ │ │ │ │ │ └── linkInfo/
│ │ │ │ │ │ ├── BlueprintClassHyperLinkInfo.kt
│ │ │ │ │ │ ├── BlueprintFunctionHyperLinkInfo.kt
│ │ │ │ │ │ ├── MethodReferenceHyperLinkInfo.kt
│ │ │ │ │ │ └── UnrealClassHyperLinkInfo.kt
│ │ │ │ │ ├── notifications/
│ │ │ │ │ │ └── OutOfSyncPluginProtocolListener.kt
│ │ │ │ │ ├── spellchecker/
│ │ │ │ │ │ └── UnrealBundledDictionaryProvider.kt
│ │ │ │ │ └── toolWindow/
│ │ │ │ │ ├── UnrealToolWindowFactory.kt
│ │ │ │ │ └── log/
│ │ │ │ │ ├── UnrealLogCategoryFilterComboBox.kt
│ │ │ │ │ ├── UnrealLogConsoleActionsPostProcessor.kt
│ │ │ │ │ ├── UnrealLogConsoleViewContentType.kt
│ │ │ │ │ ├── UnrealLogFilter.kt
│ │ │ │ │ ├── UnrealLogPanel.kt
│ │ │ │ │ ├── UnrealLogPanelSettings.kt
│ │ │ │ │ ├── UnrealLogSettings.kt
│ │ │ │ │ └── UnrealLogVerbosityFilterComboBox.kt
│ │ │ │ └── settings/
│ │ │ │ ├── UnrealLinkSettingsConfigurable.kt
│ │ │ │ ├── UnrealLogColorSettingsPage.kt
│ │ │ │ └── UnrealLogSettingsConfigurable.kt
│ │ │ └── icons/
│ │ │ └── UnrealIcons.kt
│ │ └── resources/
│ │ ├── META-INF/
│ │ │ └── plugin.xml
│ │ ├── UnrealIconMappings.json
│ │ ├── com/
│ │ │ └── jetbrains/
│ │ │ └── rider/
│ │ │ └── plugins/
│ │ │ └── unreal/
│ │ │ └── spellchecker/
│ │ │ └── unreal.dic
│ │ ├── icon-robots.txt
│ │ ├── icons/
│ │ │ └── expui/
│ │ │ └── icon-robots.txt
│ │ └── messages/
│ │ └── UnrealLinkBundle.properties
│ └── test/
│ ├── kotlin/
│ │ └── com/
│ │ └── jetbrains/
│ │ └── rider/
│ │ └── plugins/
│ │ └── unreal/
│ │ └── test/
│ │ └── cases/
│ │ ├── RiderTestDataMarker.kt
│ │ └── integrationTests/
│ │ ├── Notification.kt
│ │ ├── PlayButtons.kt
│ │ ├── UnrealLinkBase.kt
│ │ ├── UnrealLinkInstallation.kt
│ │ └── projectModel/
│ │ └── RefreshSolution.kt
│ ├── resources/
│ │ ├── episodes/
│ │ │ └── Plugins/
│ │ │ ├── UnrealIntegration.xml
│ │ │ └── UnrealLinkSmoke.xml
│ │ └── intellij.rider.plugins.unreal.link.test.cases.xml
│ └── testData/
│ ├── integrationTests/
│ │ └── projectModel/
│ │ └── RefreshSolution/
│ │ └── refreshSolution/
│ │ ├── refreshSolution.gold
│ │ ├── refreshSolution_4_27.gold
│ │ ├── refreshSolution_5_5.gold
│ │ ├── refreshSolution_text.gold
│ │ ├── refreshSolution_text_4_27.gold
│ │ ├── refreshSolution_text_5_5.gold
│ │ └── refreshSolution_text_5_7.gold
│ ├── solutions/
│ │ └── TestSolutions/
│ │ └── Unreal/
│ │ └── EmptyUProject/
│ │ ├── EmptyUProject.uproject
│ │ └── Source/
│ │ ├── EmptyUProject/
│ │ │ ├── EmptyUProject.Build.cs
│ │ │ ├── EmptyUProject.cpp
│ │ │ └── EmptyUProject.h
│ │ ├── EmptyUProject.Target.cs
│ │ └── EmptyUProjectEditor.Target.cs
│ └── unreal/
│ └── additionalSource/
│ └── plugins/
│ └── EmptyTestPlugin/
│ ├── EmptyTestPlugin.uplugin
│ └── Source/
│ └── EmptyTestPlugin/
│ ├── EmptyTestPlugin.Build.cs
│ ├── Private/
│ │ └── EmptyTestPlugin.cpp
│ └── Public/
│ └── EmptyTestPlugin.h
└── tools/
└── dotnet.cmd
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
root = true
[*.{csproj,props,targets}]
indent_style = space
indent_size = 2
================================================
FILE: .gitattributes
================================================
# Set the default behavior, in case people don't have core.autocrlf set.
* text=auto
# Keep LF in shell scripts
*.sh text eol=lf
# Preserve line endings in gradle scripts
gradlew* -text diff
================================================
FILE: .github/workflows/build.yml
================================================
name: Build UnrealLink
on:
push:
branches: [ 'net212**' ]
paths-ignore:
- src/rider/test
- testData
- README.md
- CHANGELOG.md
pull_request:
branches: [ 'net212**' ]
paths-ignore:
- src/rider/test
- testData
- README.md
- CHANGELOG.md
workflow_dispatch:
inputs:
arguments:
description: 'Additional attributes to gradle buildPlugin'
required: false
default: ''
jobs:
build:
name: ${{ matrix.config.name }}
runs-on: ${{ matrix.config.os }}
strategy:
fail-fast: false
matrix:
config:
- { name: "Windows Latest", artifact-prefix: "UnrealLink-",
os: windows-latest,
SEP: \ }
# Steps represent a sequence of tasks that will be executed as part of the job
steps:
- uses: actions/checkout@v2 # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
- uses: actions/cache@v2
with:
path: ~/.gradle/caches
key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
restore-keys: ${{ runner.os }}-gradle-
- name: Build Plugin
run: gradlew.bat buildPlugin -PbuildCounter=${{ github.run_number }} -PbuildConfiguration=Release ${{ github.event.inputs.arguments }}
shell: cmd
- name: Upload artifacts
if: success()
uses: actions/upload-artifact@v2
with:
name: ${{ matrix.config.artifact-prefix }}artifacts
path: output/**
================================================
FILE: .gitignore
================================================
# Build artifacts
[Bb]in/
[Oo]bj/
build
output
.gradle
.tmp
out/*
*.generated.*
NuGet.Config
# User-specific files
*.suo
*.user
*.sln.docstates
*.sln.binlog
*.cache
# IDEs
.idea
.vs
_ReSharper*
_dotTrace*
# Unreal Plugin generated files
src/cpp/RiderLink/RiderLink.uplugin
src/cpp/RiderLink/checksum
src/cpp/RiderLink/Binaries
src/cpp/RiderLink/Intermediate
src/cpp/RiderLink/Source/RiderLink/Public/Model
# rd-cpp extra files
CMakeLists.txt
src/cpp/RiderLink/Source/RD/**/.*
src/cpp/RiderLink/Source/RD/**/*.yml
src/cpp/RiderLink/Source/RD/**/test
src/cpp/RiderLink/Source/RD/**/tests
src/cpp/RiderLink/Source/RD/**/bench
src/cpp/RiderLink/Source/RD/**/example
src/cpp/RiderLink/Source/RD/**/pch.*
src/cpp/RiderLink/Source/RD/**/INSTALL
src/cpp/RiderLink/Source/RD/**/doxygen.conf
# Local setup specific files
UnrealEngineProjectPath.txt
dependencies/*
/.intellijPlatform/
# Tmp release files
release_notes.md
# Zipper
tools/Zipper/*
!tools/Zipper/Program.cs
!tools/Zipper/Zipper.csproj
!tools/Zipper/Zipper.sln
/src/cpp/RiderLink/Resources/checksum
================================================
FILE: .run/Debug backend.run.xml
================================================
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Debug backend" type="RunNativeExe" factoryName="Native Executable">
<option name="EXE_PATH" value="$PROJECT_DIR$/gradlew.bat" />
<option name="PROGRAM_PARAMETERS" value="runIde" />
<option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
<option name="PASS_PARENT_ENVS" value="1" />
<envs>
<env name="RESHARPER_HOST_DEBUG_SELF" value="1" />
</envs>
<option name="USE_EXTERNAL_CONSOLE" value="0" />
<method v="2">
<option name="Build Solution" enabled="true" />
</method>
</configuration>
</component>
================================================
FILE: .run/UnrealLink [runIde].run.xml
================================================
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="UnrealLink [runIde]" type="GradleRunConfiguration" factoryName="Gradle">
<ExternalSystemSettings>
<option name="executionName" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="externalSystemIdString" value="GRADLE" />
<option name="scriptParameters" value="" />
<option name="taskDescriptions">
<list />
</option>
<option name="taskNames">
<list>
<option value="runIde" />
</list>
</option>
<option name="vmOptions" />
</ExternalSystemSettings>
<ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
<DebugAllEnabled>false</DebugAllEnabled>
<RunAsTest>false</RunAsTest>
<method v="2" />
</configuration>
</component>
================================================
FILE: CHANGELOG.md
================================================
# Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0). Note that this project does not follow
semantic versioning but uses version numbers based on JetBrains [Rider](https://www.jetbrains.com/rider/) releases.
This plugin contains a plugin for the Unreal Editor (RiderLink) that is used to communicate with Rider. Changes marked
with a "Rider:" prefix are specific to Rider, while changes for the Unreal Editor plugin are marked with a "Unreal
Editor:" prefix. No prefix means that the change is common to both Rider and ReSharper.
The plugin is always bundled with Rider.
## [Unreleased]
## [2023.1.0.282]
### Fixed
- [RIDER-93789](https://youtrack.jetbrains.com/issue/RIDER-93789)
## [2023.1.0.188]
### Fixed
- Navigating from Rider to Unreal Editor for DataAssets
## [2022.3.0.200]
### Changed
- Add option to specify intermediate folder for building RiderLink plugin (File | Settings | Languages & Frameworks | Unreal Engine).
- If you have non-ASCII symbols in the path, your RiderLink build might fail.
- Add option to specify behavior of the auto-update
- Select between automatically building and installing plugin, or simply extracting sources of RiderLink and building them yourselves
- Extracting plugin might be a better option for RiderLink installed in the Game projects, or Engine project built from the sources
### Fixed
- Support installing RiderLink into the pre-built version of the UE5 (eg installed through Epic Games Launcher)
- From now on, RiderLink will be installed in the `Engine/Plugins/Marketplace/Developer/RiderLink` folder, if you chose to install it in the Engine
- Initially, RiderLink will be installed into `Plugins/Developer/RiderLink` for Game project and `Engine/Plugins/Marketplace/Developer/RiderLink` for Engine project, but if you wish to move it to another folder, Rider will take into the account the new location and will be updating the plugin in place.
## [2022.3.0.178]
### Changed
- Disable installation to Engine for UE 5
- [RIDER-71374](https://youtrack.jetbrains.com/issue/RIDER-71374)
- Unreal log panel was made more consistent with output log window in Unreal Editor
- Log categories are now sorted in popup ([RIDER-61132](https://youtrack.jetbrains.com/issue/RIDER-61132))
- Log verbosity and category popups do not hide on item toggling
- Full log messages are colorized, not only category name
### Fixed
- Fix [RIDER-69165](https://youtrack.jetbrains.com/issue/RIDER-69165)
- Fix [DEXP-642989](https://youtrack.jetbrains.com/issue/DEXP-642989)
## [2021.2.1.4]
### Fixed
- Fix [RIDER-66784](https://youtrack.jetbrains.com/issue/RIDER-66784)
- Possibly fix [RIDER-67192](https://youtrack.jetbrains.com/issue/RIDER-67192)
## [2021.2.1.3]
### Fixed
- [GITHUB-135](https://github.com/JetBrains/UnrealLink/issues/135)
## [2021.2.1.2]
### Fixed
- [GITHUB-135](https://github.com/JetBrains/UnrealLink/issues/135)
## [2021.2.1.1]
### Changed
- Sending logs from Unreal Editor to Rider moved to separate thread, less load on UE UI thread
### Fixed
- [RIDER-68865](https://youtrack.jetbrains.com/issue/RIDER-68865)
- Unreal log messages are not limited anymore with 4KB size
## [2021.2.0.659]
### Fixed
- Finally fix for [GITHUB-99](https://github.com/JetBrains/UnrealLink/issues/99)
- as well as [GITHUB-97](https://github.com/JetBrains/UnrealLink/issues/97)
- Number of fixes for clashing "Project Model Generation" with "Building RiderLink" actions blocking UnrealBuildTool.
They don't have dedicated issues in YT or GH, but has producing annoying results like:
- "can't generate project model, because UBT is running" message;
- Building RiderLink and failing would leave a hanging UBT process.
### Known Issues
## [2021.1.12]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- HOTFIX building RideLink on MacOS
### Known Issues
## [2021.1.11]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- [RIDER-63716](https://youtrack.jetbrains.com/issue/RIDER-63716)
- [RIDER-63584](https://youtrack.jetbrains.com/issue/RIDER-63584)
- [RIDER-64422](https://youtrack.jetbrains.com/issue/RIDER-64422)
- [GITHUB-109](https://github.com/JetBrains/UnrealLink/issues/109)
- [GITHUB-112](https://github.com/JetBrains/UnrealLink/issues/112)
- Possible fix for [GITHUB-99](https://github.com/JetBrains/UnrealLink/issues/99)
- Fix build RiderLink for UE5 main branch
### Known Issues
## [2021.1.10]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- [RIDER-63716](https://youtrack.jetbrains.com/issue/RIDER-63716)
- [RIDER-63584](https://youtrack.jetbrains.com/issue/RIDER-63584)
- [GITHUB-109](https://github.com/JetBrains/UnrealLink/issues/109)
- Possible fix for [GITHUB-99](https://github.com/JetBrains/UnrealLink/issues/99)
- Fix build RiderLink for UE5 main branch
### Known Issues
## [2021.1.9]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- [RIDER-63716](https://youtrack.jetbrains.com/issue/RIDER-63716)
- [RIDER-63584](https://youtrack.jetbrains.com/issue/RIDER-63584)
- [GITHUB-109](https://github.com/JetBrains/UnrealLink/issues/109)
- Possible fix for [GITHUB-99](https://github.com/JetBrains/UnrealLink/issues/99)
- Fix build RiderLink for UE5 main branch
### Known Issues
## [2021.1.8]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Possible fix for https://youtrack.jetbrains.com/issue/RIDER-62012
- UE crashing on exit in RiderLink
- Fix building RiderLink on UE5
- Fix https://github.com/JetBrains/UnrealLink/issues/93
### Known Issues
## [2021.1.7]
### Added
- Option to cancell installation of RiderLink
### Changed
### Deprecated
- Dropped support for versions of UE 4.22 and older
### Removed
### Fixed
- Fixed [Rider-51111](https://youtrack.jetbrains.com/issue/RIDER-51111)
- Fixed installation on macOS
- Failing to install RiderLink due to other UBT processes running
### Known Issues
## [2021.1.6]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fixed [Rider-51111](https://youtrack.jetbrains.com/issue/RIDER-51111)
- Fixed installation on macOS
### Known Issues
## [2021.1.5]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fixed [Rider-51111](https://youtrack.jetbrains.com/issue/RIDER-51111)
- Fixed installation on macOS
### Known Issues
## [2021.1.4]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fixed potential issues with inconsistent protocol state on disconnects
- Reinitialize protocol each time
- Fixed bunch of issues with game control actions
- Use PIE actions logic from UE4 instead of reimplementing it
- Actions are no more stuck in disabled state after engine unexpected shutdowns
### Known Issues
- "Compile before play" option is not properly supported
- Actions visibility and availability states are not synchronized with editor
## [2021.1.3]
### Added
- Disabling Play and Play settings button after press
- Rider should reflect state of Unreal Editor. Play buttons should change only when Unreal Editor notifies that they
have changed
### Changed
### Deprecated
### Removed
### Fixed
- Fix: sync state of play buttons and play settings buttns between Rider and Unreal Editor
- Fix: don't install RiderLink into `UnrealLaunchDaemon` project
### Known Issues
## [2021.1.2]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Exception on generitng project files during installation of RiderLink plugin
- Rider not being able to connect to Unreal Editor
### Known Issues
## [2021.1.1]
### Added
- Support MacOS and Linux
- Installing RiderLink plugin logs show in Build panel
### Changed
### Deprecated
### Removed
### Fixed
### Known Issues
## [2020.3.116]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fix https://github.com/JetBrains/UnrealLink/issues/62
### Known Issues
## [2020.3.113]
### Added
### Changed
- Build RiderLink plugin from source on user PC instead of bundling dll files.
- Reason: frequent changes of toolchains and breaking of ABI compatibility in MSVC toolchain render this practice
impossible.
### Deprecated
- Drop support for UE 4.21 and older
- Reason: RD framework doesn't use PCH files and doesn't comply with UE rules for include files. It's impossible to
state that module doesn't use PCH files in UE 4.21 and older.
### Removed
### Fixed
### Known Issues
## [2020.3.104]
### Added
- Proper README for the https://github.com/JetBrains/UnrealLink
### Changed
### Deprecated
### Removed
### Fixed
- Fix memory leak in log panel on exit of Rider
- Fix deprecated code
### Known Issues
## [2020.3.85]
### Added
- Supported Rider 2020.3
### Changed
### Deprecated
### Removed
### Fixed
### Known Issues
## [2020.2.83]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- More fixes to https://youtrack.jetbrains.com/issue/RIDER-50354
### Known Issues
## [2020.2.79]
### Added
- More info and notifications when RiderLink can't be built
- Unable auto-update plugin from JetBrains Marketplace
### Changed
### Deprecated
### Removed
- Removed verbose log messages from RD framework in stdout
### Fixed
- Fix https://youtrack.jetbrains.com/issue/RIDER-50354
- Fix corrupted hyperlinks after toggling timestamps
### Known Issues
## [2020.2.69]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fix https://github.com/JetBrains/UnrealLink/issues/46
### Known Issues
## [2020.2.67]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fix showing popup "update project file" after installing RiderLink
- After pressing "update project file", it'd update {GameProject}.uproject file, adding reference to RiderLink. This
is not necessary for RiderLink to work properly, but it'll break project for people that will sink to
{GameProject}.uproject, but who doesn't have RiderLink installed
### Known Issues
## [2020.2.66]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fix https://github.com/JetBrains/UnrealLink/issues/40
- Fix https://youtrack.jetbrains.com/issue/RIDER-47839
### Known Issues
## [2020.2.62]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fixed: https://github.com/JetBrains/UnrealLink/issues/19
### Known Issues
## [2020.2.61]
### Added
- Unreal log filters
- Verbosity
- Category
- Show/hide timestamps
### Changed
- Generated files for RD protocol will have ".Generated.h" suffix
### Deprecated
### Removed
- Packing plugin for ReSharper
- Not supported yet
### Fixed
- Fixed: building RiderLink with Unity build disabled
- Fixed: Wording in "Install RiderLink" popup
- Fixed: Wording in UnrealEngine settings
- No more auto-install plugin, only auto-update plugin
### Known Issues
## [2020.2.36]
### Added
### Changed
- rd-cpp updated to 201.1.85
### Deprecated
### Removed
### Fixed
- Fixed stackoverflow crash on exit of Unreal Editor
### Known Issues
## [2020.2.34]
### Added
### Changed
- move plugin installation in backend thread - no more freeze of UI when installing RiderLink
### Deprecated
### Removed
### Fixed
- fix loading RiderLink plugin on cooking
- fix crash on closing UnrealEditor in RiderLoggingExtension
- fixed number of problems discovering Unreal Editor installation, should fix a lot of false failing installations of
RiderLink
- fix wording in RiderLink settings panel ( auto update and install -> auto update)
- fix UnrealBuildTool removing EnableByDefault: true from RiderLink.uplugin
- No more modification of {GameName}.uproject file to enable RiderLink
### Known Issues
## [2020.1.10]
### Added
- Add option to install plugin to either Engine or Game
- Installing to Engine from EGS requires building plugin
- Old versions of plugins will be backed up
- New version will be copied to %USER% folder and built
- Result binaries copyied to Engine or Game
- Sln will be refreshed
- In case of errors, all the results will be reverted
### Changed
- Moved thirdparty dependencies of RD to submodules, fixed build.kts for it
### Deprecated
### Removed
### Fixed
- [Extremely long log entry causes RiderLink to lose connection to Unreal Engine](https://github.com/JetBrains/UnrealLink/issues/17)
- Fix looking for Unreal Engine root when Game is placed in the same folder as Engine
- Fix RiderLink for non-Unity builds
### Known Issues
## [2020.1.8]
### Added
- Add progress bar when installing "RiderLink" plugin
- Hide notification suggesting installing RiderLink after selecting "Install plugin"
- [Add option to Compile Game Project before starting PIE](https://github.com/JetBrains/UnrealLink/issues/9)
### Changed
- Installation to Engine instead of game Project
- [Add option to install RiderLink to Engine instead of Game Project](https://github.com/JetBrains/UnrealLink/issues/7)
- During installation process, RiderLink will be built and put into correct folder
- No more gimmicks with "build plugin in Game project, then copy-paste it in Engine project"
- Refactored "RiderLink"
- Separated "RiderLink" into separate module with different loading steps
- e.g. For "RiderLink', start as soon as possible, for "RiderLinkGameControlExtension" start after Unreal Editor is
fully loaded, etc
- Fixed all warnings (TEXT macro redefined, obsolete API, etc)
### Deprecated
### Removed
### Fixed
- Lower verbosity of RD protocol logger
- Less noise in debug console
- [Build on non-unity projects](https://github.com/JetBrains/UnrealLink/issues/10)
- [Exception during installation of RiderLink](https://github.com/JetBrains/UnrealLink/issues/5)
- [Multiple popups suggesting installing RiderLink](https://youtrack.jetbrains.com/issue/RIDER-43928)
- Bunch of issues:
- https://youtrack.jetbrains.com/issue/RIDER-44056
- https://youtrack.jetbrains.com/issue/RIDER-44027
- https://youtrack.jetbrains.com/issue/RIDER-43929
### Known Issues
## [2020.1.7]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- [Incorrect time in log](https://github.com/JetBrains/UnrealLink/issues/8)
- [Infinite process: RiderLink Discovering Asset Data](https://youtrack.jetbrains.com/issue/RIDER-43353)
- Spawn of multiple tabs when sending huge log message from Unreal Editor to Rider
### Known Issues
## [2020.1.6]
### Added
- FileWatcher initialization moved to separate thread, speed up startup time for plugin on RIder side
- New icons for Play actions and connection status
### Changed
- Cleaned up severity of internal logs
- Were polluting package logs
### Deprecated
### Removed
### Fixed
- Connecting to Unreal Editor when plugin is installed in Engine
### Known Issues
## [2020.1.5]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- [Cant close Unreal log window](https://github.com/JetBrains/UnrealLink/issues/2)
- Disabled spawning multiple tabs for logs. Only one log tab for Unreal Editor log will be available at all times
- [Rider installs plugins to Programs](https://github.com/JetBrains/UnrealLink/issues/6)
- [Exception: The process cannot access the file because it is being used by another process](https://github.com/JetBrains/UnrealLink/issues/5)
- [Crash in RiderLink when packaging project](https://github.com/JetBrains/UnrealLink/issues/4)
### Known Issues
## [2020.1.4]
### Added
- Option to enable auto-update Unreal Editor (RiderLink) plugin
- Notification after plugin installation
### Changed
### Deprecated
### Removed
### Fixed
- Not finding uproject files on loading solution
- [UnrealLink plugin generates wrong sln for Rocket builds of UE](https://github.com/JetBrains/UnrealLink/issues/1)
### Known Issues
## [2020.1.2]
### Added
### Changed
### Deprecated
### Removed
### Fixed
- Fixed: when adding RiderLink plugin to project, Rider would regenerate sln and It would add Programs folder to
solution tree for Rocket builds (UE from EGS)
- Fixed: building plugin on v4.20+
- Fixed: Use user temp folder instead of the project folder for intermediate file operations to avoid asking for
elevated options
### Known Issues
## [2020.1.1]
### Added
- Open Blueprints from Rider
- Show logs of Unreal Editor inside Rider with hyperlinks to Blueprints inside Rider
- Toolbar buttons to control playback of the game inside Unreal Editor
- Play, Pause, Stop, Skip frame;
- Setup multiplayer: number of players, dedicated server, etc.
- Notification if connection to Unreal Editor is established or not (bottom right corner of status bar);
- Auto-install plugins in project;
- Setting to enable auto-install (`true` by default).
- If auto-install is disabled - notification will show up with quick-fix action.
### Changed
### Deprecated
### Removed
### Fixed
### Known Issues
- Service for opening assets in Unreal Editor has changed starting with UE 4.24 - opening same BP multiple times will
open multiple tabs instead of re-using already opened one;
- Icon for connection status looks weird, waiting for new icons from designers
- Connecting to multiple instances of Unreal Editor is not working correctly
- Toolbar controls will be affecting only the last connected editor
================================================
FILE: CODE_OF_CONDUCT.md
================================================
## Code of Conduct
This project and the corresponding community is governed by the [JetBrains Open Source and Community Code of Conduct](https://confluence.jetbrains.com/display/ALL/JetBrains+Open+Source+and+Community+Code+of+Conduct). Please make sure you read it.
================================================
FILE: License.txt
================================================
Apache License
Version 2.0, January 2004
https://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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.txt
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.
================================================
FILE: README.md
================================================
[](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
# UnrealLink for Unreal Engine
<p>The UnrealLink plugin enables advanced integration between JetBrains <a href="https://www.jetbrains.com/lp/rider-unreal/">Rider</a> and Epic Games’ <a href="https://www.unrealengine.com/en-US/">Unreal Editor</a>.</p>
<p>Rider is a fast and powerful IDE for Unreal Engine and C++ development. It provides rich code navigation, inspections, refactorings, understands Blueprints and the Unreal Engine reflection mechanism, and supports HLSL.</p>
<p>The plugin brings Blueprints information to the editor, adds settings to manage game launch, and provides a more convenient version of the Unreal Editor log.</p>
<ul>
<li>
<a href="#plugin-structure">Plugin structure</a>
</li>
<li>
<a href="#installation">Installation</a>
</li>
<li>
<a href="#contribution">Contribution</a>
</li>
<li>
<a href="#features">Features</a>
</li>
<li>
<a href="#what-could-possibly-go-wrong">What could possibly go wrong?</a>
</li>
</ul>
<h2 id="plugin-structure">Plugin structure</h2>
<p>There are two plugins under the hood, the <strong>UnrealLink</strong> plugin for Rider and the <strong>RiderLink</strong> plugin for Unreal Editor, packed together.</p>
<h2 id="installation">Installation</h2>
<p><strong>UnrealLink</strong> is bundled with Rider and also distributed via the JetBrains plugin <a href="https://plugins.jetbrains.com/plugin/14989-unreal-link">marketplace</a>.</p>
<p><strong>RiderLink</strong> is installed by Rider itself, there is no need to install it manually. The first time you open an Unreal Engine project in Rider, you'll see a notification that the RiderLink plugin is missing and an invitation to install it. If you skip this popup message, you can install the plugin later by going to the Rider settings on the <em>Languages and Frameworks | Unreal Engine</em> page.</p>
<p>Both the popup message and the settings page offer two installation options:</p>
<ul>
<li>
<em>Engine</em>: Select this option to install the plugin in the engine and use it for all game projects based on the current engine version. The plugin will appear in the <code>Engine/Plugins/Developer</code> folder.
</li>
<li>
<em>Game</em>: Select this option to install the plugin in the game project and use it for the current project only. The plugin will appear in the <code>Game/Plugins/Developer</code> folder.
</li>
</ul>
<h2 id="contribution">Contribute to the plugin</h2>
<p>We love contributions! If you want to contribute to the UnrealLink plugin, fork this repository and follow the instructions on <a href="SETUP.md">how to set up a development environment</a>.</p>
<h2 id="features">Features</h2>
<h3 id="interact_with_blueprints">Interact with blueprints</h3>
<p>Blueprint files are written in binary form and are usually edited visually. However, they contain a whole lot of useful information for the developers of the C++ part of the game.</p>
<p>Rider reads Blueprints and allows you to see the bigger picture behind your code:</p>
<ul>
<li>
There may be derived blueprint classes, which you can see by invoking <em>Find Usages</em> on a C++ class or when you're browsing your C++ code in the editor.
</li>
<li>
You can see the values of overridden properties.
</li>
</ul>
<p>UnrealLink extends this functionality and introduces the ability to navigate to the Blueprint inside the Unreal Editor from your C++ code.</p>
<img alt="Interact with blueprints" width="800" src="https://plugins.jetbrains.com/files/14989/screenshot_23450.png"/>
<h3 id="manage_the_game">Manage the game</h3>
<p>The plugin allows you to manage your game right inside the IDE: select the running mode, run a server for your multiplayer game, specify the number of players, and more.</p>
<img alt="Manage the game" width="800" src="https://plugins.jetbrains.com/files/14989/screenshot_23451.png"/>
<h3 id="browse_the_unreal_editor_log">Browse the Unreal Editor log</h3>
<p>UnrealLink offers you an enhanced version of the Unreal Editor log output panel with colored text for easy reading, as well as verbosity and event category filters. You can also click on any highlighted link to navigate to the related source code line.</p>
<img alt="Browse the Unreal Editor log" width="800" src="https://plugins.jetbrains.com/files/14989/screenshot_23452.png"/>
<a href="https://www.jetbrains.com/help/rider/Working_with_Unreal_Engine.html">Learn more about Rider for Unreal Engine >></a>
<h2 id="what-could-possibly-go-wrong">What could possibly go wrong?</h2>
<p>The plugin and Rider for Unreal Engine itself are in active development now, so there could be some issues. Please share your feedback and report any bugs you encounter:</p>
<ul>
<li>
Submit plugin-specific issues to the <a href="https://github.com/JetBrains/UnrealLink/issues">GitHub Issues page</a>.
</li>
<li>
Rider-specific issues should be directed to the <a href="https://youtrack.jetbrains.com/issues/RIDER">Rider tracker</a>.
</li>
<li>
Send a message with any questions and feature suggestions to our support engineers and the Rider for Unreal Engine developers at <a href="mailto:rider-cpp-support@jetbrains.com">rider-cpp-support@jetbrains.com</a>. We really love hearing from you!
</li>
</ul>
<p>A few typical issues, and what to do in such cases:</p>
<h5 id=failed_build>Failed to build RiderLink plugin</h5>
```
Failed to build RiderLink plugin
Check build logs for more info
Help > Diagnostic Tools > Show Log in Explorer
And contact dev team for help at GitHub Issues page
```
<p>There are several reasons you might get this message:</p>
<ul>
<li>
There’s a problem with your current Game or Unreal Engine code. Please make sure that you can build them correctly.
</li>
<li>
You have an instance of Unreal Editor with the RiderLink plugin running. Please close Unreal Editor and try installing RiderLink again.
</li>
<li>
Finally, if Unreal Editor is closed and your project builds fine, and you have an old version of RiderLink installed, please move the old version of RiderLink to a temp folder manually and try reinstalling RiderLink.
</li>
</ul>
<h5 id=failed_backup>Failed to backup old plugin</h5>
```
Failed to backup old plugin
Close all running instances of Unreal Editor and try again
Path to old plugin:
```
<p>You tried to install a new version of RiderLink while you have a running instance of Unreal Editor with the plugin installed. Please close Unreal Editor and try again to install the plugin.</p>
<h5 id=failed_refresh>Failed to refresh project files</h5>
<p>This warning message means that installation was successful, but updating the project files in Rider failed. Everything should work fine, except the plugin will not appear in the <code>/Plugins/Developer</code> folder in the Explorer view.</p>
<p>If you have any issues with the plugin that you can’t resolve, please contact the developers via <a href="https://github.com/JetBrains/UnrealLink/issues">GitHub Issues</a>.</p>
================================================
FILE: SETUP.md
================================================
<h1>Setting up development environment</h1>
<p>After cloning the repository, you need to perform some actions to set up the environment.</p>
<h2>[TBD] Setting up UnrealLink frontend</h2>
<h2>Setting up UnrealLink backend</h2>
<ul>
<li>
Run the console under the folder where you have cloned the repository.
<p><strong>NOTE:</strong> Make sure that you have Java installed on your machine and you have environmental variable JAVA_HOME set to the value of the path to your JDK folder. Otherwise, it won't work.</p>
</li>
<li>
Use the following command <code>gradlew buildResharperHost</code> to install all the requirements for proper work
</li>
</ul>
<p>Here you go! Now you can open UnrealLink.sln and work on backend code.</p>
<h2>Setting up RiderLink, Unreal Editor plugin</h2>
<p>Code for the Unreal Editor part is stored inside UnrealLink repository, but in order to work with cpp code, it should be a part of Unreal Engine project.
As a workaround, we provide an option to create a junction from RiderLink source folder to Unreal Engine game project.
That way, when you make changes to RiderLink plugin inside Unreal Engine project, they will be picked up automatically in git.</p>
<ul>
<li>Run the console under the folder where you have cloned the repository</li>
<li>Use the following command <code>gradlew symlinkPluginToUnrealProject</code>
<ul>
<li>It will fail the first time with the message "Add path to a valid UnrealEngine project folder to: {UnrealLinkRoot}\UnrealEngineProjectPath.txt"</li>
<li>and will create "UnrealEngineProjectPath.txt" for you.</li>
</ul>
</li>
<li>Add path to the root folder of your game project into "UnrealEngineProjectPath.txt" eg "D:/PROJECTS/UE/basic_4_26"</li>
<li>Run <code>gradlew symlinkPluginToUnrealProject</code> again.</li>
<li>Refresh project files for your Game project</li>
</ul>
<p>RiderLink plugin will be available under <code>{GameProjectRoot}/Plugins/Development/RiderLink</code></p>
================================================
FILE: SdkBasedPluginEmbedding.Root
================================================
================================================
FILE: SubplatformsCollection.Root
================================================
================================================
FILE: UnrealLink.sln
================================================
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.29123.88
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RiderPlugin.UnrealLink", "src\dotnet\RiderPlugin.UnrealLink\RiderPlugin.UnrealLink.csproj", "{084172D1-A9C6-46D0-96AD-05C5B09A5E5D}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "misc", "misc", "{4A9ABB95-3762-448B-B5BF-099E46DB22DE}"
ProjectSection(SolutionItems) = preProject
CHANGELOG.md = CHANGELOG.md
src\dotnet\Plugin.props = src\dotnet\Plugin.props
src\rider\main\resources\META-INF\plugin.xml = src\rider\main\resources\META-INF\plugin.xml
README.md = README.md
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{084172D1-A9C6-46D0-96AD-05C5B09A5E5D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{084172D1-A9C6-46D0-96AD-05C5B09A5E5D}.Debug|Any CPU.Build.0 = Debug|Any CPU
{084172D1-A9C6-46D0-96AD-05C5B09A5E5D}.Release|Any CPU.ActiveCfg = Release|Any CPU
{084172D1-A9C6-46D0-96AD-05C5B09A5E5D}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {AE34A340-CA1E-400F-9367-864EEF8033C7}
EndGlobalSection
EndGlobal
================================================
FILE: build.gradle.kts
================================================
import com.jetbrains.plugin.structure.base.utils.isFile
import org.apache.tools.ant.taskdefs.condition.Os
import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.jetbrains.changelog.Changelog
import org.jetbrains.intellij.platform.gradle.tasks.PrepareSandboxTask
import org.jetbrains.intellij.platform.gradle.tasks.RunIdeTask
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import java.io.ByteArrayOutputStream
import java.security.MessageDigest
import javax.inject.Inject
import org.gradle.process.ExecOperations
import kotlin.io.path.absolute
import kotlin.io.path.isDirectory
import org.jetbrains.intellij.platform.gradle.Constants
import org.jetbrains.intellij.platform.gradle.TestFrameworkType
import kotlin.io.path.pathString
plugins {
id("me.filippov.gradle.jvm.wrapper") version "0.16.0"
id("org.jetbrains.changelog") version "2.0.0"
id("org.jetbrains.intellij.platform")
kotlin("jvm")
}
interface Injected {
@get:Inject val exec: ExecOperations
}
val injected = objects.newInstance<Injected>()
java {
sourceCompatibility = JavaVersion.VERSION_25
targetCompatibility = JavaVersion.VERSION_25
}
repositories {
maven("https://cache-redirector.jetbrains.com/intellij-dependencies")
maven("https://cache-redirector.jetbrains.com/intellij-repository/releases")
maven("https://cache-redirector.jetbrains.com/intellij-repository/snapshots")
maven("https://cache-redirector.jetbrains.com/maven-central")
intellijPlatform {
defaultRepositories()
jetbrainsRuntime()
}
}
dependencies {
testImplementation("com.fasterxml.jackson.core:jackson-databind:2.14.0")
}
apply {
plugin("kotlin")
}
kotlin {
sourceSets {
main {
kotlin.srcDir("src/rider/main/kotlin")
}
test {
kotlin.srcDir("src/rider/test/kotlin")
}
}
}
sourceSets {
main {
kotlin.srcDir("src/rider/generated/kotlin")
resources.srcDir("src/rider/main/resources")
}
}
project.version = "${property("majorVersion")}." +
"${property("minorVersion")}." +
"${property("buildCounter")}"
if (System.getenv("TEAMCITY_VERSION") != null) {
logger.lifecycle("##teamcity[buildNumber '${project.version}']")
} else {
logger.lifecycle("Plugin version: ${project.version}")
}
val buildConfigurationProp = project.property("buildConfiguration").toString()
val repoRoot by extra { project.rootDir }
val isWindows by extra { Os.isFamily(Os.FAMILY_WINDOWS) }
val idePluginId by extra { "RiderPlugin" }
val dotNetSolutionId by extra { "UnrealLink" }
val dotNetDir by extra { File(repoRoot, "src/dotnet") }
val dotNetBinDir by extra { dotNetDir.resolve("$idePluginId.$dotNetSolutionId").resolve("bin") }
val dotNetPluginId by extra { "$idePluginId.${project.name}" }
val dotNetSolution by extra { File(repoRoot, "$dotNetSolutionId.sln") }
val modelDir = File(repoRoot, "protocol/src/main/kotlin/model")
val hashBaseDir = File(repoRoot, "build/rdgen")
val ktOutputRelativePath = "src/rider/main/kotlin/com/jetbrains/rider/model"
val cppOutputRoot = File(repoRoot, "src/cpp/RiderLink/Source/RiderLink/Public/Model")
val csOutputRoot = File(repoRoot, "src/dotnet/RiderPlugin.UnrealLink/obj/model")
val ktOutputRoot = File(repoRoot, ktOutputRelativePath)
val riderLinkDir = File("$rootDir/src/cpp/RiderLink")
val currentBranchName = getBranchName()
fun TaskContainerScope.setupCleanup(task: Task) {
withType<Delete> {
delete(task.outputs.files)
}
}
fun getBranchName(): String {
val execResult = providers.exec {
executable = "git"
args("rev-parse", "--abbrev-ref", "HEAD")
workingDir = projectDir
isIgnoreExitValue = true
}
if (execResult.result.get().exitValue == 0) {
val output = execResult.standardOutput.asText.get().trim()
if (output.isNotEmpty())
return output
}
return "net222"
}
fun getProductMonorepoRoot(): File? {
var currentDir = repoRoot
while (currentDir.parent != null) {
if (currentDir.resolve(".ultimate.root.marker").exists()) {
return currentDir
}
currentDir = currentDir.parentFile
}
return null
}
changelog {
version.set(project.version.toString())
// https://github.com/JetBrains/gradle-changelog-plugin/blob/main/src/main/kotlin/org/jetbrains/changelog/Changelog.kt#L23
// This is just common semVerRegex with the addition of a forth optional group (number) ( x.x.x[.x][-alpha43] )
headerParserRegex.set(
"""^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)\.?(0|[1-9]\d*)?(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)
(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?${'$'}"""
.trimMargin().toRegex())
groups.set(listOf("Added", "Changed", "Deprecated", "Removed", "Fixed", "Known Issues"))
keepUnreleasedSection.set(true)
itemPrefix.set("-")
}
dependencies {
intellijPlatform {
val dependencyPath = File(projectDir, "dependencies")
if (dependencyPath.exists()) {
val localPath = dependencyPath.canonicalPath
local(localPath)
logger.lifecycle("Will use ${File(localPath, "build.txt").readText()} from $localPath as RiderSDK")
} else {
val version = "${project.property("majorVersion")}-SNAPSHOT"
logger.lifecycle("*** Using Rider SDK $version from intellij-snapshots repository")
rider(version, useInstaller = false)
}
jetbrainsRuntime()
// Workaround for https://youtrack.jetbrains.com/issue/IDEA-179607
bundledPlugin("rider.intellij.plugin.appender")
bundledPlugin("com.intellij.cidr.debugger")
bundledPlugin("com.jetbrains.rider-cpp")
// TODO: Temporary I hope hope hope
bundledLibrary(provider {
project.intellijPlatform.platformPath.resolve("lib/testFramework.jar").pathString
})
}
}
intellijPlatform {
tasks {
val currentReleaseNotesAsHtml = """
<body>
<p><b>New in "${project.version}"</b></p>
<p>${changelog.renderItem(changelog.getLatest(), Changelog.OutputType.HTML)}</p>
<p>See the <a href="https://github.com/JetBrains/UnrealLink/blob/$currentBranchName/CHANGELOG.md">CHANGELOG</a> for more details and history.</p>
</body>
""".trimIndent()
val currentReleaseNotesAsMarkdown = """
## New in ${project.version}
${changelog.renderItem(changelog.getLatest())}
See the [CHANGELOG](https://github.com/JetBrains/UnrealLink/blob/$currentBranchName/CHANGELOG.md) for more details and history.
""".trimIndent()
val dumpCurrentChangelog by registering {
val outputFile = layout.buildDirectory.file("release_notes.md")
outputs.file(outputFile)
doLast { file(outputFile).writeText(currentReleaseNotesAsMarkdown) }
}
// PatchPluginXml gets the latest (always Unreleased) section from the current changelog and writes it into plugin.xml
// dumpCurrentChangelog dumps the same section to file (for Marketplace changelog)
// After, patchChangelog rename [Unreleased] to [202x.x.x.x] and create new empty Unreleased.
// So order is important!
patchPluginXml { changeNotes.set( provider { currentReleaseNotesAsHtml }) }
patchChangelog { mustRunAfter(patchPluginXml, dumpCurrentChangelog) }
publishPlugin {
dependsOn(patchPluginXml, dumpCurrentChangelog, patchChangelog)
token.set(System.getenv("UNREALLINK_intellijPublishToken"))
val pubChannels = project.findProperty("publishChannels")
if ( pubChannels != null) {
val chan = pubChannels.toString().split(',')
println("Channels for publish $chan")
channels.set(chan)
} else {
channels.set(listOf("alpha"))
}
}
}
}
val riderModel: Configuration by configurations.creating {
isCanBeConsumed = true
isCanBeResolved = false
}
artifacts {
add(riderModel.name, provider {
intellijPlatform.platformPath.resolve("lib/rd/rider-model.jar").also {
check(it.isFile) {
"rider-model.jar is not found at $riderModel"
}
}
}) {
builtBy(Constants.Tasks.INITIALIZE_INTELLIJ_PLATFORM_PLUGIN)
}
}
tasks {
val dotNetSdkPath by lazy {
val sdkPath = intellijPlatform.platformPath.resolve("lib/DotNetSdkForRdPlugins").absolute()
assert(sdkPath.isDirectory())
println(".NET SDK path: $sdkPath")
return@lazy sdkPath.toRealPath()
}
instrumentCode {
enabled = false
}
withType<RunIdeTask>().configureEach {
maxHeapSize = "4096m"
}
withType<Test>().configureEach {
maxHeapSize = "4096m"
if (project.hasProperty("ignoreFailures")) { ignoreFailures = true }
useTestNG {
}
testLogging {
showStandardStreams = true
showExceptions = true
exceptionFormat = TestExceptionFormat.FULL
}
}
withType<KotlinCompile>().configureEach {
dependsOn("generateModels")
compilerOptions {
jvmTarget.set(JvmTarget.JVM_25)
}
}
val prepareRiderBuildProps by registering {
group = "RiderBackend"
val generatedFile = layout.buildDirectory.file("DotNetSdkPath.generated.props")
inputs.property("dotNetSdkFile", { dotNetSdkPath.toString() })
outputs.file(generatedFile)
doLast {
project.file(generatedFile).writeText(
"""<Project>
| <PropertyGroup>
| <DotNetSdkPath>$dotNetSdkPath</DotNetSdkPath>
| </PropertyGroup>
|</Project>""".trimMargin()
)
}
}
val prepareNuGetConfig by registering {
group = "RiderBackend"
dependsOn(prepareRiderBuildProps)
val generatedFile = project.projectDir.resolve("NuGet.Config")
inputs.property("dotNetSdkFile", { dotNetSdkPath.toString() })
outputs.file(generatedFile)
doLast {
val dotNetSdkFile = dotNetSdkPath
logger.info("dotNetSdk location: '$dotNetSdkFile'")
val nugetConfigText = """<?xml version="1.0" encoding="utf-8"?>
|<configuration>
| <packageSources>
| <clear />
| <add key="local-dotnet-sdk" value="$dotNetSdkFile" />
| <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
| </packageSources>
|</configuration>
""".trimMargin()
generatedFile.writeText(nugetConfigText)
logger.info("Generated content:\n$nugetConfigText")
}
}
val buildResharperHost by registering {
group = "RiderBackend"
description = "Build backend for Rider"
dependsOn(":generateModels", prepareNuGetConfig)
inputs.file(file(dotNetSolution))
inputs.dir(file("$repoRoot/src/dotnet"))
outputs.dir(file("$repoRoot/src/dotnet/RiderPlugin.UnrealLink/bin/RiderPlugin.UnrealLink/$buildConfigurationProp"))
doLast {
val warningsAsErrors: String by project.extra
val buildArguments = listOf(
"build",
dotNetSolution.canonicalPath,
"-consoleLoggerParameters:ErrorsOnly",
"/p:Configuration=$buildConfigurationProp",
"/p:Version=${project.version}",
"/p:TreatWarningsAsErrors=$warningsAsErrors",
"/bl:${dotNetSolution.name}.binlog",
"/nologo"
)
logger.info("call dotnet.cmd with '{}'", buildArguments)
injected.exec.exec {
executable = "$rootDir/tools/dotnet.cmd"
args = buildArguments
workingDir = dotNetSolution.parentFile
}
}
}
val patchUpluginVersion by register("patchUpluginVersion") {
val pathToUpluginTemplate = File("${project.rootDir}/src/cpp/RiderLink/RiderLink.uplugin.template")
val filePathToUplugin = File("${project.rootDir}/src/cpp/RiderLink/RiderLink.uplugin")
inputs.file(pathToUpluginTemplate)
inputs.property("version", project.version)
outputs.file(filePathToUplugin)
doLast {
if(filePathToUplugin.exists())
filePathToUplugin.delete()
pathToUpluginTemplate.copyTo(filePathToUplugin)
val text = filePathToUplugin.readLines().map {
it.replace("%PLUGIN_VERSION%", "${project.version}")
}
filePathToUplugin.writeText(text.joinToString(System.lineSeparator()))
}
}
withType<Delete> {
delete(patchUpluginVersion.outputs.files)
}
val generateChecksum by register("generateChecksum") {
dependsOn(":generateModels")
val upluginFile = riderLinkDir.resolve("RiderLink.uplugin.template")
val resourcesDir = riderLinkDir.resolve("Resources")
val sourceDir = riderLinkDir.resolve("Source")
val checksumFile = riderLinkDir.resolve("Resources/checksum")
inputs.file(upluginFile)
inputs.dir(resourcesDir)
inputs.dir(sourceDir)
outputs.file(checksumFile)
doLast {
checksumFile.delete()
val inputFiles = sequence{
yield(upluginFile)
resourcesDir.walkTopDown().forEach { if(it.isFile && (it.nameWithoutExtension != "checksum")) yield(it) }
sourceDir.walkTopDown().forEach { if(it.isFile) yield(it) }
}
val instance = MessageDigest.getInstance("MD5")
inputFiles.forEach { instance.update(it.readBytes()) }
checksumFile.writeBytes(instance.digest())
}
}
withType<Delete> {
delete(generateChecksum.outputs.files)
}
val packCppSide by registering(Zip::class) {
dependsOn(patchUpluginVersion)
dependsOn(":generateModels")
dependsOn(generateChecksum)
archiveFileName.set("RiderLink.zip")
excludes.addAll(arrayOf("RiderLink.uplugin.template", "Intermediate", "Binaries"))
destinationDirectory.set(File("$rootDir/build/distributions"))
from("$rootDir/src/cpp/RiderLink")
}
withType<PrepareSandboxTask> {
dependsOn(buildResharperHost, packCppSide)
outputs.upToDateWhen { false } //need to dotnet artifacts be included when only dotnet sources were changed
val outputFolder = dotNetBinDir
.resolve(dotNetPluginId)
.resolve(buildConfigurationProp)
val dllFiles = listOf(
File(outputFolder, "$dotNetPluginId.dll"),
File(outputFolder, "$dotNetPluginId.pdb")
)
dllFiles.forEach {
from(it) { into("${intellijPlatform.projectName.get()}/dotnet") }
}
from(packCppSide.get().archiveFile) {
into("${intellijPlatform.projectName.get()}/EditorPlugin")
}
doLast {
dllFiles.forEach { file ->
if (!file.exists()) throw RuntimeException("File $file does not exist")
}
}
}
val generateModels by registering {
group = "protocol"
description = "Generates protocol models."
dependsOn(":protocol:rdgen")
}
withType<Delete> {
delete(csOutputRoot, cppOutputRoot, ktOutputRoot)
}
buildSearchableOptions { }
val getUnrealEngineProject by register("getUnrealEngineProject") {
doLast {
val ueProjectPathTxt = rootDir.resolve("UnrealEngineProjectPath.txt")
if (ueProjectPathTxt.exists()) {
val ueProjectPath = ueProjectPathTxt.readText()
val ueProjectPathDir = File(ueProjectPath)
if (!ueProjectPathDir.exists()) throw AssertionError("$ueProjectPathDir doesn't exist")
if (!ueProjectPathDir.isDirectory) throw AssertionError("$ueProjectPathDir is not directory")
val isUEProject = ueProjectPathDir.listFiles()?.any {
it.extension == "uproject"
}
if (isUEProject == true) {
extra["UnrealProjectPath"] = ueProjectPathDir
} else {
throw AssertionError("Add path to a valid UnrealEngine project folder to: $ueProjectPathTxt")
}
} else {
ueProjectPathTxt.createNewFile()
throw AssertionError("Add path to a valid UnrealEngine project folder to: $ueProjectPathTxt")
}
}
}
val symlinkPluginToUnrealProject by registering {
dependsOn(getUnrealEngineProject)
dependsOn(patchUpluginVersion)
doLast {
val unrealProjectPath = getUnrealEngineProject.extra["UnrealProjectPath"] as File
val targetDir = File("$unrealProjectPath/Plugins/Developer/RiderLink")
if(targetDir.exists()) {
val stdOut = ByteArrayOutputStream()
// Check if it's Junction
val result = injected.exec.exec {
commandLine = if(isWindows)
listOf("cmd.exe", "/c", "fsutil", "reparsepoint", "query", targetDir.absolutePath, "|", "find", "Print Name:")
else
listOf("find", targetDir.absolutePath, "-maxdepth", "1", "-type", "l", "-ls")
isIgnoreExitValue = true
standardOutput = stdOut
}
// Check if it's Junction to local RiderLink
if(result.exitValue == 0) {
val output = stdOut.toString().trim()
if (output.isNotEmpty()) {
val pathToJunction = if (isWindows)
output.substringAfter("Print Name:").trim()
else
output.substringAfter("->").trim()
if (File(pathToJunction) == riderLinkDir) {
println("Junction is already correct")
throw StopExecutionException()
}
}
}
// If it's not Junction or if it's a Junction but doesn't point to local RiderLink - delete it
targetDir.delete()
}
targetDir.parentFile.mkdirs()
val stdOut = ByteArrayOutputStream()
val result = injected.exec.exec {
commandLine = if(isWindows)
listOf("cmd.exe", "/c", "mklink", "/J", targetDir.absolutePath, riderLinkDir.absolutePath)
else
listOf("ln", "-s", riderLinkDir.absolutePath, targetDir.absolutePath)
errorOutput = stdOut
isIgnoreExitValue = true
}
if (result.exitValue != 0) {
println(stdOut.toString().trim())
}
}
}
wrapper {
gradleVersion = "9.4.1"
distributionUrl = "https://cache-redirector.jetbrains.com/services.gradle.org/distributions/gradle-${gradleVersion}-bin.zip"
}
}
================================================
FILE: gradle/wrapper/gradle-wrapper.properties
================================================
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://cache-redirector.jetbrains.com/services.gradle.org/distributions/gradle-9.4.1-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
================================================
FILE: gradle.properties
================================================
# Properties for the build. Override on the command line with -Pprop=value
# E.g. -PBuildConfiguration=Release
# Note that these values are strings!
# Local builds and installs will have this ridiculours number 20xx.x.x.9999
# Teamcity overrides buildCounter to %build.counter% (Teamcity counter)
# majorVersion is used as SDK version when no SDK in UnrealLink/dependencies
# Downloads "majorVersion-SNAPSHOT" from https://cache-redirector.jetbrains.com/intellij-repository/snapshots
majorVersion=2026.3
minorVersion=0
buildCounter=9999
# Overrides on Teamcity to Release
buildConfiguration=Debug
warningsAsErrors=false
# List of channels to publish. Defined as comma-separated string (publishChannels="alpha,beta,eap")
# Alpha channel uses by default =)
#publishChannels=alpha
# We need it to avoid bundle Kotlin jars into plugin
kotlin.stdlib.default.dependency=false
# Updated automatically on idea sync
rdVersion=2026.1.3
rdKotlinVersion=2.3.0
intellijPlatformGradlePluginVersion=2.11.0
gradleJvmWrapperVersion=0.15.0
org.gradle.jvmargs=-Xmx4g
================================================
FILE: gradlew
================================================
#!/bin/sh
#
# Copyright © 2015 the original 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.
#
# SPDX-License-Identifier: Apache-2.0
#
##############################################################################
#
# Gradle start up script for POSIX generated by Gradle.
#
# Important for running:
#
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
# noncompliant, but you have some other compliant shell such as ksh or
# bash, then to run this script, type that shell name before the whole
# command line, like:
#
# ksh Gradle
#
# Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features:
# * functions;
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
# * compound commands having a testable exit status, especially «case»;
# * various built-in commands including «command», «set», and «ulimit».
#
# Important for patching:
#
# (2) This script targets any POSIX shell, so it avoids extensions provided
# by Bash, Ksh, etc; in particular arrays are avoided.
#
# The "traditional" practice of packing multiple parameters into a
# space-separated string is a well documented source of bugs and security
# problems, so this is (mostly) avoided, by progressively accumulating
# options in "$@", and eventually passing that to Java.
#
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
# see the in-line comments for details.
#
# There are tweaks for specific operating systems such as AIX, CygWin,
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/2d6327017519d23b96af35865dc997fcb544fb40/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
app_path=$0
# Need this for daisy-chained symlinks.
while
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
[ -h "$app_path" ]
do
ls=$( ls -ld "$app_path" )
link=${ls#*' -> '}
case $link in #(
/*) app_path=$link ;; #(
*) app_path=$APP_HOME$link ;;
esac
done
# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
warn () {
echo "$*"
} >&2
die () {
echo
echo "$*"
echo
exit 1
} >&2
# 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 ;; #(
MSYS* | MINGW* ) msys=true ;; #(
NONSTOP* ) nonstop=true ;;
esac
# GRADLE JVM WRAPPER START MARKER
BUILD_DIR="${HOME}/.local/share/gradle-jvm"
JVM_ARCH=$(uname -m)
JVM_TEMP_FILE=$BUILD_DIR/gradle-jvm-temp.tar.gz
if [ "$darwin" = "true" ]; then
case $JVM_ARCH in
x86_64)
JVM_URL=https://download.oracle.com/java/25/archive/jdk-25.0.2_macos-x64_bin.tar.gz
JVM_TARGET_DIR=$BUILD_DIR/jdk-25.0.2_macos-x64_bin-99fbca
;;
arm64)
JVM_URL=https://download.oracle.com/java/25/archive/jdk-25.0.2_macos-aarch64_bin.tar.gz
JVM_TARGET_DIR=$BUILD_DIR/jdk-25.0.2_macos-aarch64_bin-d7817e
;;
*)
die "Unknown architecture $JVM_ARCH"
;;
esac
elif [ "$cygwin" = "true" ] || [ "$msys" = "true" ]; then
JVM_URL=https://download.oracle.com/java/25/archive/jdk-25.0.2_windows-x64_bin.zip
JVM_TARGET_DIR=$BUILD_DIR/jdk-25.0.2_windows-x64_bin-96701c
else
JVM_ARCH=$(linux$(getconf LONG_BIT) uname -m)
case $JVM_ARCH in
x86_64)
JVM_URL=https://download.oracle.com/java/25/archive/jdk-25.0.2_linux-x64_bin.tar.gz
JVM_TARGET_DIR=$BUILD_DIR/jdk-25.0.2_linux-x64_bin-3c4431
;;
aarch64)
JVM_URL=https://download.oracle.com/java/25/archive/jdk-25.0.2_linux-aarch64_bin.tar.gz
JVM_TARGET_DIR=$BUILD_DIR/jdk-25.0.2_linux-aarch64_bin-a88282
;;
*)
die "Unknown architecture $JVM_ARCH"
;;
esac
fi
set -e
if [ -e "$JVM_TARGET_DIR/.flag" ] && [ -n "$(ls "$JVM_TARGET_DIR")" ] && [ "x$(cat "$JVM_TARGET_DIR/.flag")" = "x${JVM_URL}" ]; then
# Everything is up-to-date in $JVM_TARGET_DIR, do nothing
true
else
echo "Downloading $JVM_URL to $JVM_TEMP_FILE"
rm -f "$JVM_TEMP_FILE"
mkdir -p "$BUILD_DIR"
if command -v curl >/dev/null 2>&1; then
if [ -t 1 ]; then CURL_PROGRESS="--progress-bar"; else CURL_PROGRESS="--silent --show-error"; fi
# shellcheck disable=SC2086
curl $CURL_PROGRESS -L --output "${JVM_TEMP_FILE}" "$JVM_URL" 2>&1
elif command -v wget >/dev/null 2>&1; then
if [ -t 1 ]; then WGET_PROGRESS=""; else WGET_PROGRESS="-nv"; fi
wget $WGET_PROGRESS -O "${JVM_TEMP_FILE}" "$JVM_URL" 2>&1
else
die "ERROR: Please install wget or curl"
fi
echo "Extracting $JVM_TEMP_FILE to $JVM_TARGET_DIR"
rm -rf "$JVM_TARGET_DIR"
mkdir -p "$JVM_TARGET_DIR"
case "$JVM_URL" in
*".zip") unzip "$JVM_TEMP_FILE" -d "$JVM_TARGET_DIR" ;;
*) tar -x -f "$JVM_TEMP_FILE" -C "$JVM_TARGET_DIR" ;;
esac
rm -f "$JVM_TEMP_FILE"
echo "$JVM_URL" >"$JVM_TARGET_DIR/.flag"
fi
JAVA_HOME=
for d in "$JVM_TARGET_DIR" "$JVM_TARGET_DIR"/* "$JVM_TARGET_DIR"/Contents/Home "$JVM_TARGET_DIR"/*/Contents/Home; do
if [ -e "$d/bin/java" ]; then
JAVA_HOME="$d"
fi
done
if [ '!' -e "$JAVA_HOME/bin/java" ]; then
die "Unable to find bin/java under $JVM_TARGET_DIR"
fi
# Make it available for child processes
export JAVA_HOME
set +e
# GRADLE JVM WRAPPER END MARKER
# 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
if ! command -v java >/dev/null 2>&1
then
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
fi
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
case $MAX_FD in #(
max*)
# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
MAX_FD=$( ulimit -H -n ) ||
warn "Could not query maximum file descriptor limit"
esac
case $MAX_FD in #(
'' | soft) :;; #(
*)
# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC2039,SC3045
ulimit -n "$MAX_FD" ||
warn "Could not set maximum file descriptor limit to $MAX_FD"
esac
fi
# Collect all arguments for the java command, stacking in reverse order:
# * args from the command line
# * the main class name
# * -classpath
# * -D...appname settings
# * --module-path (only if needed)
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
# Now convert the arguments - kludge to limit ourselves to /bin/sh
for arg do
if
case $arg in #(
-*) false ;; # don't mess with options #(
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
[ -e "$t" ] ;; #(
*) false ;;
esac
then
arg=$( cygpath --path --ignore --mixed "$arg" )
fi
# Roll the args list around exactly as many times as the number of
# args, so each arg winds up back in the position where it started, but
# possibly modified.
#
# NB: a `for` loop captures its iteration list before it begins, so
# changing the positional parameters here affects neither the number of
# iterations, nor the values presented in `arg`.
shift # remove old arg
set -- "$@" "$arg" # push replacement arg
done
fi
# 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"'
# Collect all arguments for the java command:
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
# and any embedded shellness will be escaped.
# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
# treated as '${Hostname}' itself on the command line.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
"$@"
# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
die "xargs is not available"
fi
# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
# set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#
eval "set -- $(
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
xargs -n1 |
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
tr '\n' ' '
)" '"$@"'
exec "$JAVACMD" "$@"
================================================
FILE: 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 https://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
@rem SPDX-License-Identifier: Apache-2.0
@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=.
@rem This is normally unused
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 GRADLE JVM WRAPPER START MARKER
setlocal
set BUILD_DIR=%LOCALAPPDATA%\gradle-jvm
for /f "tokens=3 delims= " %%A in ('reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v "PROCESSOR_ARCHITECTURE"') do set WIN_ARCH=%%A
if "%WIN_ARCH%" equ "AMD64" (
set JVM_TARGET_DIR=%BUILD_DIR%\jdk-25.0.2_windows-x64_bin-96701c\
set JVM_URL=https://download.oracle.com/java/25/archive/jdk-25.0.2_windows-x64_bin.zip
) else if "%WIN_ARCH%" equ "ARM64" (
set JVM_TARGET_DIR=%BUILD_DIR%\microsoft-jdk-25.0.2-windows-aarch64-7d2a81\
set JVM_URL=https://aka.ms/download-jdk/microsoft-jdk-25.0.2-windows-aarch64.zip
) else (
echo Unknown architecture %WIN_ARCH%
goto fail
)
set IS_TAR_GZ=0
set JVM_TEMP_FILE=gradle-jvm.zip
if /I "%JVM_URL:~-7%"==".tar.gz" (
set IS_TAR_GZ=1
set JVM_TEMP_FILE=gradle-jvm.tar.gz
)
set POWERSHELL=%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe
if not exist "%JVM_TARGET_DIR%" MD "%JVM_TARGET_DIR%"
if not exist "%JVM_TARGET_DIR%.flag" goto downloadAndExtractJvm
set /p CURRENT_FLAG=<"%JVM_TARGET_DIR%.flag"
if "%CURRENT_FLAG%" == "%JVM_URL%" goto continueWithJvm
:downloadAndExtractJvm
PUSHD "%BUILD_DIR%"
if errorlevel 1 goto fail
echo Downloading %JVM_URL% to %BUILD_DIR%\%JVM_TEMP_FILE%
if exist "%JVM_TEMP_FILE%" DEL /F "%JVM_TEMP_FILE%"
"%POWERSHELL%" -nologo -noprofile -Command "Set-StrictMode -Version 3.0; $ErrorActionPreference = \"Stop\"; (New-Object Net.WebClient).DownloadFile('%JVM_URL%', '%JVM_TEMP_FILE%')"
if errorlevel 1 goto fail
POPD
RMDIR /S /Q "%JVM_TARGET_DIR%"
if errorlevel 1 goto fail
MKDIR "%JVM_TARGET_DIR%"
if errorlevel 1 goto fail
PUSHD "%JVM_TARGET_DIR%"
if errorlevel 1 goto fail
echo Extracting %BUILD_DIR%\%JVM_TEMP_FILE% to %JVM_TARGET_DIR%
if "%IS_TAR_GZ%"=="1" (
tar xf "..\\%JVM_TEMP_FILE%"
) else (
"%POWERSHELL%" -nologo -noprofile -command "Set-StrictMode -Version 3.0; $ErrorActionPreference = \"Stop\"; Add-Type -A 'System.IO.Compression.FileSystem'; [IO.Compression.ZipFile]::ExtractToDirectory('..\\%JVM_TEMP_FILE%', '.');"
)
if errorlevel 1 goto fail
DEL /F "..\%JVM_TEMP_FILE%"
if errorlevel 1 goto fail
POPD
echo %JVM_URL%>"%JVM_TARGET_DIR%.flag"
if errorlevel 1 goto fail
:continueWithJvm
set JAVA_HOME=
for /d %%d in ("%JVM_TARGET_DIR%"*) do if exist "%%d\bin\java.exe" set JAVA_HOME=%%d
if not exist "%JAVA_HOME%\bin\java.exe" (
echo Unable to find java.exe under %JVM_TARGET_DIR%
goto fail
)
endlocal & set JAVA_HOME=%JAVA_HOME%
@rem GRADLE JVM WRAPPER END MARKER
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute
echo. 1>&2
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo. 1>&2
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2
goto fail
:execute
@rem Setup the command line
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
:end
@rem End local scope for the variables with windows NT shell
if %ERRORLEVEL% equ 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!
set EXIT_CODE=%ERRORLEVEL%
if %EXIT_CODE% equ 0 set EXIT_CODE=1
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
exit /b %EXIT_CODE%
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
================================================
FILE: protocol/build.gradle.kts
================================================
import com.jetbrains.rd.generator.gradle.RdGenTask
plugins {
// Version is configured in gradle.properties
id("com.jetbrains.rdgen")
id("org.jetbrains.kotlin.jvm")
}
repositories {
maven("https://cache-redirector.jetbrains.com/intellij-dependencies")
maven("https://cache-redirector.jetbrains.com/maven-central")
val rd_version: String? by project
if (rd_version == "SNAPSHOT") {
mavenLocal()
}
}
val isMonorepo = rootProject.projectDir != projectDir.parentFile
val unrealLinkRepoRoot: File = projectDir.parentFile
sourceSets {
main {
kotlin {
srcDir(unrealLinkRepoRoot.resolve("protocol/src/main/kotlin/model"))
}
}
}
data class UnrealLinkGeneratorSettings(
val ue4LibCsLibraryOutput: File,
val ue4LibCppLibraryOutput: File,
val ue4LibKtLibraryOutput: File,
val riderModelCsOutput: File,
val riderModelKtOutput: File,
val csEditorOutput: File,
val cppEditorOutput: File,
val fileSuffix: String
)
val ktOutputRelativePath = "src/rider/generated/kotlin/com/jetbrains/rider/model"
val unrealLinkGeneratorSettings = if (isMonorepo) {
val monorepoRoot =
buildscript.sourceFile?.parentFile?.parentFile?.parentFile?.parentFile?.parentFile ?: error("Cannot find products home")
check(monorepoRoot.resolve(".ultimate.root.marker").isFile) {
error("Incorrect location in monorepo: monorepoRoot='$monorepoRoot'")
}
val monorepoPreGeneratedRootDir = monorepoRoot.resolve("dotnet/Plugins/_UnrealLink.Pregenerated")
val monorepoPreGeneratedFrontendDir = monorepoPreGeneratedRootDir.resolve("Frontend")
val monorepoPreGeneratedBackendDir = monorepoPreGeneratedRootDir.resolve("BackendModel")
val monorepoPreGeneratedCppDir = monorepoPreGeneratedRootDir.resolve("CppModel")
val ktOutputMonorepoRoot = monorepoPreGeneratedFrontendDir.resolve(ktOutputRelativePath)
UnrealLinkGeneratorSettings(
monorepoPreGeneratedBackendDir.resolve("Library"),
monorepoPreGeneratedCppDir.resolve( "Library"),
ktOutputMonorepoRoot.resolve("Library"),
monorepoPreGeneratedBackendDir.resolve("RdRiderProtocol"),
ktOutputMonorepoRoot.resolve("RdRiderProtocol"),
monorepoPreGeneratedBackendDir.resolve("RdEditorProtocol"),
monorepoPreGeneratedCppDir.resolve("RdEditorProtocol"),
".Pregenerated"
)
} else {
val csOutputRoot = File(unrealLinkRepoRoot, "src/dotnet/RiderPlugin.UnrealLink/obj/model")
val cppOutputRoot = File(unrealLinkRepoRoot, "src/cpp/RiderLink/Source/RiderLink/Public/Model")
val ktOutputRoot = File(unrealLinkRepoRoot, ktOutputRelativePath)
UnrealLinkGeneratorSettings(
csOutputRoot.resolve("Library"),
cppOutputRoot.resolve( "Library"),
ktOutputRoot.resolve("Library"),
csOutputRoot.resolve("RdRiderProtocol"),
ktOutputRoot.resolve("RdRiderProtocol"),
csOutputRoot.resolve("RdEditorProtocol"),
cppOutputRoot.resolve("RdEditorProtocol"),
".Pregenerated"
)
}
rdgen {
verbose = true
packages = "model.editorPlugin,model.lib.ue4,model.rider"
generator {
language = "csharp"
transform = "symmetric"
root = "model.lib.ue4.UE4Library"
directory = unrealLinkGeneratorSettings.ue4LibCsLibraryOutput.absolutePath
generatedFileSuffix = unrealLinkGeneratorSettings.fileSuffix
}
generator {
language = "cpp"
transform = "reversed"
root = "model.lib.ue4.UE4Library"
directory = unrealLinkGeneratorSettings.ue4LibCppLibraryOutput.absolutePath
generatedFileSuffix = unrealLinkGeneratorSettings.fileSuffix
}
generator {
language = "kotlin"
transform = "asis"
root = "model.lib.ue4.UE4Library"
directory = unrealLinkGeneratorSettings.ue4LibKtLibraryOutput.absolutePath
generatedFileSuffix = unrealLinkGeneratorSettings.fileSuffix
}
generator {
language = "csharp"
transform = "reversed"
root = "com.jetbrains.rider.model.nova.ide.IdeRoot"
directory = unrealLinkGeneratorSettings.riderModelCsOutput.absolutePath
generatedFileSuffix = unrealLinkGeneratorSettings.fileSuffix
}
generator {
language = "kotlin"
transform = "asis"
root = "com.jetbrains.rider.model.nova.ide.IdeRoot"
directory = unrealLinkGeneratorSettings.riderModelKtOutput.absolutePath
generatedFileSuffix = unrealLinkGeneratorSettings.fileSuffix
}
generator {
language = "csharp"
transform = "asis"
root = "model.editorPlugin.RdEditorRoot"
directory = unrealLinkGeneratorSettings.csEditorOutput.absolutePath
generatedFileSuffix = unrealLinkGeneratorSettings.fileSuffix
}
generator {
language = "cpp"
transform = "reversed"
root = "model.editorPlugin.RdEditorRoot"
directory = unrealLinkGeneratorSettings.cppEditorOutput.absolutePath
generatedFileSuffix = unrealLinkGeneratorSettings.fileSuffix
}
}
tasks.withType<RdGenTask> {
dependsOn(sourceSets["main"].runtimeClasspath)
classpath(sourceSets["main"].runtimeClasspath)
}
dependencies {
if (isMonorepo) {
implementation(project(":rider-model"))
} else {
val rdVersion: String by project
val rdKotlinVersion: String by project
implementation("com.jetbrains.rd:rd-gen:$rdVersion")
implementation("org.jetbrains.kotlin:kotlin-stdlib:$rdKotlinVersion")
implementation(
project(
mapOf(
"path" to ":",
"configuration" to "riderModel"
)
)
)
}
}
================================================
FILE: protocol/src/main/kotlin/model/editorPlugin/LiveCodingModel.kt
================================================
package model.editorPlugin
import com.jetbrains.rd.generator.nova.*
import com.jetbrains.rd.generator.nova.PredefinedType.*
@Suppress("unused")
object LiveCodingModel : Ext(RdEditorModel) {
init {
call("LC_IsEnabledByDefault", void, bool)
source("LC_EnableByDefault", bool)
call("LC_IsEnabledForSession", void, bool)
call("LC_CanEnableForSession", void, bool)
source("LC_EnableForSession", bool)
call("LC_IsCompiling", void, bool)
call("LC_HasStarted", void, bool)
source("LC_Compile", void)
sink("LC_OnPatchComplete", void)
}
}
================================================
FILE: protocol/src/main/kotlin/model/editorPlugin/RdEditorModel.kt
================================================
package model.editorPlugin
import com.jetbrains.rd.generator.nova.*
import com.jetbrains.rd.generator.nova.PredefinedType.*
import com.jetbrains.rd.generator.nova.cpp.Cpp17Generator
import com.jetbrains.rd.generator.nova.csharp.CSharp50Generator
import model.lib.ue4.UE4Library
@Suppress("unused")
object RdEditorRoot : Root() {
init {
setting(CSharp50Generator.Namespace, "RiderPlugin.UnrealLink.Model.BackendUnreal")
setting(Cpp17Generator.Namespace, "JetBrains::EditorPlugin")
setting(Cpp17Generator.AdditionalHeaders, listOf("UE4TypesMarshallers.h"))
setting(Cpp17Generator.ExportMacroName, "RIDERLINK_API")
setting(Cpp17Generator.GeneratePrecompiledHeaders, false)
setting(Cpp17Generator.UsePrecompiledHeaders, false)
}
}
@Suppress("unused")
object RdEditorModel : Ext(RdEditorRoot) {
init {
property("connectionInfo", UE4Library.ConnectionInfo).readonly
signal("unrealLog", UE4Library.UnrealLogEvent).async
signal("openBlueprint", UE4Library.BlueprintReference)
signal("onBlueprintAdded", UE4Library.UClass).async
call("isBlueprintPathName", UE4Library.FString, bool)
call("getPathNameByPath", UE4Library.FString, UE4Library.FString.nullable)
callback("AllowSetForegroundWindow", int, bool)
property("isGameControlModuleInitialized", false).readonly
sink("PlayStateFromEditor", UE4Library.PlayState)
source("RequestPlayFromRider", int)
source("RequestPauseFromRider", int)
source("RequestResumeFromRider", int)
source("RequestStopFromRider", int)
source("RequestFrameSkipFromRider", int)
sink("NotificationReplyFromEditor", UE4Library.RequestResultBase)
sink("PlayModeFromEditor", int)
source("PlayModeFromRider", int)
// Hot Reload here is not Unreal's HotReload but generic Hot Reload mechanism which can be either Unreal's HotReload or Unreal's LiveCoding
property("IsHotReloadAvailable", false).readonly
property("IsHotReloadCompiling", false).readonly
source("TriggerHotReload", void)
}
}
================================================
FILE: protocol/src/main/kotlin/model/lib/ue4/UE4Library.kt
================================================
package model.lib.ue4
import com.jetbrains.rd.generator.nova.*
import com.jetbrains.rd.generator.nova.PredefinedType.*
import com.jetbrains.rd.generator.nova.cpp.Cpp17Generator
import com.jetbrains.rd.generator.nova.cpp.CppIntrinsicType
import com.jetbrains.rd.generator.nova.csharp.CSharp50Generator
import com.jetbrains.rd.generator.nova.kotlin.Kotlin11Generator
object UE4Library : Root() {
init {
setting(Kotlin11Generator.Namespace, "com.jetbrains.rider.plugins.unreal.model")
setting(CSharp50Generator.Namespace, "RiderPlugin.UnrealLink.Model")
setting(Cpp17Generator.Namespace, "JetBrains::EditorPlugin")
setting(Cpp17Generator.AdditionalHeaders, listOf(
"UE4TypesMarshallers.h",
"Runtime/Core/Public/Containers/Array.h",
"Runtime/Core/Public/Containers/ContainerAllocationPolicies.h"
))
setting(Cpp17Generator.ListType, CppIntrinsicType(null, "TArray", "Containers/Array.h"))
setting(Cpp17Generator.AllocatorType) { "FDefaultAllocator" }
setting(Cpp17Generator.ExportMacroName, "RIDERLINK_API")
setting(Cpp17Generator.GeneratePrecompiledHeaders, false)
setting(Cpp17Generator.UsePrecompiledHeaders, false)
}
private fun <T : Declaration> declare(intrinsic: CppIntrinsicType, factory: Toplevel.() -> T): T {
return this.factory().apply {
intrinsic.namespace?.let { ns ->
setting(Cpp17Generator.Namespace, ns)
}
setting(Cpp17Generator.Intrinsic, intrinsic)
}
}
val StringRange = structdef("StringRange") {
field("first", int)
field("last", int)
}
val FString = declare(CppIntrinsicType(null, "FString", "Containers/UnrealString.h")) {
structdef("FString") {
field("data", string)
}
}
val PlayState = enum("PlayState") {
+"Idle"
+"Play"
+"Pause"
}
val RequestResultBase = basestruct("RequestResultBase") {
field("requestID", int)
}
@Suppress("unused")
val RequestSucceed = structdef("RequestSucceed") extends RequestResultBase {
}
@Suppress("unused")
val RequestFailed = structdef("RequestFailed") extends RequestResultBase {
field("type", enum("NotificationType") {
+"Message"
+"Error"
})
field("message", FString)
}
val VerbosityType = declare(CppIntrinsicType("ELogVerbosity", "Type", "Logging/LogVerbosity.h"))
{
setting(Cpp17Generator.IsNonScoped, "uint8")
enum("VerbosityType") {
(+"NoLogging").doc("= 0")
(+"Fatal").doc(
"Always prints a fatal error to console (and log file) and crashes (even if logging is disabled)"
)
(+"Error").doc(
"Prints an error to console (and log file)." +
"Command lets and the editor collect and report errors. Error messages result in command let failure."
)
(+"Warning").doc(
"Prints a warning to console (and log file)." +
"Command lets and the editor collect and report warnings. Warnings can be treated as an error.")
(+"Display").doc(
"Prints a message to console (and log file)"
)
(+"Log").doc("Prints a message to a log file (does not print to console)")
(+"Verbose").doc(
"Prints a verbose message to a log file (if Verbose logging is enabled for the given category, usually used for detailed logging)"
)
(+"VeryVerbose").doc(
"Prints a verbose message to a log file (if VeryVerbose logging is enabled, usually used for detailed logging that would otherwise spam output)"
)
// Log masks and special Enum values
(+"All")/*.setting(Cpp17Generator.EnumConstantValue, 7)*/.doc("=VeryVerbose")
(+"NumVerbosity")
(+"VerbosityMask").setting(Cpp17Generator.EnumConstantValue, 0xf)
(+"SetColor").setting(Cpp17Generator.EnumConstantValue, 0x40).doc("not actually a verbosity, used to set the color of an output device")
(+"BreakOnLog").setting(Cpp17Generator.EnumConstantValue, 0x80)
}
}
private val LogMessageInfo = structdef("LogMessageInfo") {
field("type", VerbosityType)
field("category", FString)
field("time", dateTime.nullable)
}
val UnrealLogEvent = structdef("UnrealLogEvent") {
field("info", LogMessageInfo)
field("text", FString)
field("bpPathRanges", immutableList(StringRange))
field("methodRanges", immutableList(StringRange))
}
/*@Suppress("unused")
private val LogMessageEvent = structdef("LogMessageEvent") extends LogEvent {
field("message", FString)
}*/
val UClass = structdef("UClass") {
field("name", FString)
}
@Suppress("unused")
val BlueprintFunction = structdef("BlueprintFunction") {
field("class", UClass)
field("name", FString)
const("separator", string, ":")
}
//region Script Call Stack
private val ScriptCallStackFrame = structdef("ScriptCallStackFrame") {
// field("header", FString)
// field("blueprintFunction", BlueprintFunction)
field("entry", FString)
}
private val IScriptCallStack = basestruct("IScriptCallStack") {
const("header", string, "Script call stack:")
}
@Suppress("unused")
private val EmptyScriptCallStack = structdef("EmptyScriptCallStack") extends IScriptCallStack {
const("message", string, "Script call stack: [Empty] (FFrame::GetStackTrace() called from native code)")
}
@Suppress("unused")
private val ScriptCallStack = structdef("ScriptCallStack") extends IScriptCallStack {
field("frames", immutableList(ScriptCallStackFrame))
}
@Suppress("unused")
private val UnableToDisplayScriptCallStack = structdef("UnableToDisplayScriptCallStack") extends IScriptCallStack {
const("message", string, "Unable to display Script Callstack. Compile with DO_BLUEPRINT_GUARD=1")
}
//endregion
//region ScriptMsg
private val IScriptMsg = basestruct("IScriptMsg") {
const("header", string, "Script msg:")
}
@Suppress("unused")
private val ScriptMsgException = structdef("ScriptMsgException") extends IScriptMsg {
field("message", FString)
}
@Suppress("unused")
private val ScriptMsgCallStack = structdef("ScriptMsgCallStack") extends IScriptMsg {
field("message", FString)
field("scriptCallStack", IScriptCallStack)
}
/*
@Suppress("unused")
private val ScriptMsgEvent = structdef("ScriptMsgEvent") extends LogPart {
field("scriptMsg", IScriptMsg)
}
*/
//endregion
@Suppress("unused")
val BlueprintHighlighter = structdef("BlueprintHighlighter") {
field("begin", int)
field("end", int)
}
val BlueprintReference = structdef("BlueprintReference") {
field("pathName", FString)
field("guid", FString)
}
val ConnectionInfo = structdef("ConnectionInfo") {
field("projectName", string)
field("executableName", string)
field("processId", int)
}
}
================================================
FILE: protocol/src/main/kotlin/model/rider/RdRiderModel.kt
================================================
package model.rider
import com.jetbrains.rd.generator.nova.*
import com.jetbrains.rd.generator.nova.PredefinedType.*
import com.jetbrains.rd.generator.nova.csharp.CSharp50Generator
import com.jetbrains.rd.generator.nova.kotlin.Kotlin11Generator
import com.jetbrains.rider.model.nova.ide.SolutionModel
import model.lib.ue4.UE4Library
@Suppress("unused")
object RdRiderModel : Ext(SolutionModel.Solution) {
init {
setting(Kotlin11Generator.Namespace, "com.jetbrains.rider.plugins.unreal.model.frontendBackend")
setting(CSharp50Generator.Namespace, "RiderPlugin.UnrealLink.Model.FrontendBackend")
}
private val LinkRequest = structdef("LinkRequest") {
field("data", UE4Library.FString)
}
val ILinkResponse = basestruct("ILinkResponse") {}
val LinkResponseBlueprint = structdef("LinkResponseBlueprint") extends ILinkResponse {
field("fullPath", UE4Library.FString)
field("range", UE4Library.StringRange)
}
val LinkResponseFilePath = structdef("LinkResponseFilePath") extends ILinkResponse {
field("fullPath", UE4Library.FString)
field("range", UE4Library.StringRange)
}
val LinkResponseUnresolved = structdef("LinkResponseUnresolved") extends ILinkResponse {}
private val MethodReference = structdef("MethodReference") {
field("class", UE4Library.UClass)
field("method", UE4Library.FString)
const("separator", string, "::")
}
private val PluginInstallStatus = enum("PluginInstallStatus") {
+"NoPlugin"
+"UpToDate"
+"InEngine"
+"InGame"
}
private val EditorPluginOutOfSync = structdef("EditorPluginOutOfSync") {
field("status", PluginInstallStatus)
field("IsGameAvailable", bool)
}
private val InstallMessage = structdef("InstallMessage") {
field("text", string)
field("type", enum("ContentType") {
+"Normal"
+"Error"
})
}
private val InstallPluginDescription = structdef("InstallPluginDescription") {
field("location", enum("PluginInstallLocation") {
+"Engine"
+"Game"
+"NotInstalled"
})
field("forceInstall", enum("ForceInstall") {
+"Yes"
+"No"
})
field("buildRequired", bool).default(true)
field("selectedUprojectPaths", immutableList(string))
field("unselectedUprojectPaths", immutableList(string))
}
private val GamePluginInstallInfo = structdef("GamePluginInstallInfo") {
field("projectName", string)
field("uprojectPath", string)
field("isPluginAvailable", bool)
field("isPluginSynced", bool)
}
init {
property("editorId", 0).readonly.async
signal("unrealLog", UE4Library.UnrealLogEvent)
call("filterLinkCandidates", immutableList(LinkRequest), array(ILinkResponse)).async
call("isMethodReference", MethodReference, bool).async
signal("navigateToMethod", MethodReference)
signal("navigateToClass", UE4Library.UClass)
signal("openBlueprint", UE4Library.BlueprintReference)
callback("AllowSetForegroundWindow", int, bool)
property("isConnectedToUnrealEditor", false).readonly.async
property("isUnrealEngineSolution", false)
property("isPreBuiltEngine", false)
property("connectionInfo", UE4Library.ConnectionInfo).readonly
sink("onEditorPluginOutOfSync", EditorPluginOutOfSync)
source("installEditorPlugin", InstallPluginDescription)
source("refreshProjects", void)
source("enableAutoupdatePlugin", void)
property("isGameControlModuleInitialized", false).readonly
sink("PlayStateFromEditor", UE4Library.PlayState)
source("RequestPlayFromRider", int)
source("RequestPauseFromRider", int)
source("RequestResumeFromRider", int)
source("RequestStopFromRider", int)
source("RequestFrameSkipFromRider", int)
sink("NotificationReplyFromEditor", UE4Library.RequestResultBase)
sink("PlayModeFromEditor", int)
source("PlayModeFromRider", int)
sink("RiderLinkInstallPanelInit", void)
sink("RiderLinkInstallMessage", InstallMessage).async
sink("InstallPluginFinished", bool).async
property("RiderLinkInstallationInProgress", false)
property("RefreshInProgress", false)
property("IsUproject", false)
property("isInstallInfoAvailable", false)
sink("gamePluginInstallInfos", immutableList(GamePluginInstallInfo))
source("CancelRiderLinkInstall", void)
// Hot Reload here is not Unreal's HotReload but generic Hot Reload mechanism which can be either Unreal's HotReload or Unreal's LiveCoding
property("IsHotReloadAvailable", false).readonly
property("IsHotReloadCompiling", false).readonly
signal("TriggerHotReload", void)
signal("DeletePlugin", void)
}
}
================================================
FILE: settings.gradle.kts
================================================
rootProject.name = "UnrealLink"
pluginManagement {
val rdVersion: String by settings
val rdKotlinVersion: String by settings
val intellijPlatformGradlePluginVersion: String by settings
val gradleJvmWrapperVersion: String by settings
repositories {
maven("https://cache-redirector.jetbrains.com/intellij-dependencies")
maven("https://cache-redirector.jetbrains.com/plugins.gradle.org")
maven("https://cache-redirector.jetbrains.com/maven-central")
if (rdVersion == "SNAPSHOT") {
mavenLocal()
}
}
plugins {
id("com.jetbrains.rdgen") version rdVersion
id("org.jetbrains.kotlin.jvm") version rdKotlinVersion
id("org.jetbrains.intellij.platform") version intellijPlatformGradlePluginVersion
id("me.filippov.gradle.jvm.wrapper") version gradleJvmWrapperVersion
}
resolutionStrategy {
eachPlugin {
when (requested.id.name) {
// This required to correctly rd-gen plugin resolution.
// Maybe we should switch our naming to match Gradle plugin naming convention.
"rdgen" -> {
useModule("com.jetbrains.rd:rd-gen:${rdVersion}")
}
}
}
}
}
include(":protocol")
================================================
FILE: setup_unreal_plugin.cmd
================================================
.\gradlew -q symlinkPluginToUnrealProject
================================================
FILE: src/SubplatformsCollection.Root
================================================
================================================
FILE: src/cpp/BuildScript/GenerateRiderLinkZip.cs
================================================
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Security.Cryptography;
using JetBrains.Application.BuildScript;
using JetBrains.Application.BuildScript.Compile;
using JetBrains.Application.BuildScript.Solution;
using JetBrains.Build;
using JetBrains.Extension;
using JetBrains.Util;
using JetBrains.Util.dataStructures;
using JetBrains.Util.Special;
using JetBrains.Util.Storage;
namespace Plugins.UnrealLink.src.cpp.BuildScript
{
public class GenerateRiderLinkZip
{
[BuildStep]
public static SubplatformFileForPackaging[] Run(AllAssembliesOnEverything allass, ProductHomeDirArtifact homedir, ILogger logger)
{
if (allass.FindSubplatformByClass<GenerateRiderLinkZip>() is SubplatformOnSources subplatform)
{
FileSystemPath dirRiderLink = homedir.ProductHomeDir / subplatform.Name.RelativePath / "RiderLink";
FileSystemPath dirModel = dirRiderLink.Parent.Parent.Parent.Parent / "_UnrealLink.Pregenerated" / "CppModel";
IList<ImmutableFileItem> files = dirRiderLink.GetChildFiles(flags: PathSearchFlags.RecurseIntoSubdirectories)
.OrderBy().Select(file => ImmutableFileItem.CreateFromDisk(file).WithRelativePath(file.MakeRelativeTo(dirRiderLink))).ToList();
IList<ImmutableFileItem> models = dirModel.GetChildFiles(flags: PathSearchFlags.RecurseIntoSubdirectories)
.OrderBy().Select(file => ImmutableFileItem.CreateFromDisk(file).WithRelativePath((RelativePath)"Source" / "RiderLink" / "Public" / "Model" / file.MakeRelativeTo(dirModel))).ToList();
files.AddRange(models);
ImmutableFileItem fiUpluginTemplate = files.Single(fi => fi.RelativePath == "RiderLink.uplugin.template");
StreamEx.TextAndEncoding taeUpluginTemplate = fiUpluginTemplate.FileContent.ReadTextFromFile();
string sUpluginContent = taeUpluginTemplate.Text.Replace("%PLUGIN_VERSION%", GlobalDefines.FullMarketingVersionString);
ImmutableFileItem fiUplugin = new ImmutableFileItem(fiUpluginTemplate.RelativePath.NameWithoutExtension, ImmutableByteStream.FromByteArray(taeUpluginTemplate.Encoding.GetBytes(sUpluginContent).ToImmutableArray()));
byte[] bytesChecksumContent = MD5.Create().WithDispose(hasher =>
{
foreach (var fi in files) hasher.TransformBlock(fi.FileContent);
hasher.TransformFinalBlock(Array.Empty<byte>(), 0, 0);
return hasher.Hash;
});
ImmutableFileItem fiChecksum = new ImmutableFileItem("Resources/checksum", ImmutableByteStream.FromByteArray(bytesChecksumContent.ToImmutableArray()));
ImmutableFileItem fiZip = Compression.ZipCompress(dirRiderLink.Name + ExtensionConstants.Zip, files.Where(fi => fi != fiUpluginTemplate).Concat(fiUplugin, fiChecksum), logger, whencompress: Compression.WhenToCompressEntry.Always);
return new[] { new SubplatformFileForPackaging(subplatform.Name, fiZip) };
}
return Array.Empty<SubplatformFileForPackaging>();
}
}
}
================================================
FILE: src/cpp/RiderLink/RiderLink.uplugin.template
================================================
{
"FileVersion": 3,
"Version": 1,
"VersionName": "%PLUGIN_VERSION%",
"FriendlyName": "RiderLink",
"Description": "Plugin for establishing IPC connection with JetBrains Rider IDE",
"Category": "Programming",
"CreatedBy": "JetBrains",
"CreatedByURL": "https://www.jetbrains.com/",
"DocsURL": "",
"MarketplaceURL": "",
"SupportURL": "",
"EnabledByDefault": true,
"CanContainContent": false,
"IsBetaVersion": false,
"Installed": false,
"Modules": [
{
"Name": "RD",
"Type": "EditorNoCommandlet",
"LoadingPhase": "PreDefault"
},
{
"Name": "RiderLink",
"Type": "EditorNoCommandlet",
"LoadingPhase": "PreDefault"
},
{
"Name": "RiderLogging",
"Type": "EditorNoCommandlet",
"LoadingPhase": "PreDefault"
},
{
"Name": "RiderBlueprint",
"Type": "EditorNoCommandlet",
"LoadingPhase": "Default"
},
{
"Name": "RiderGameControl",
"Type": "EditorNoCommandlet",
"LoadingPhase": "Default"
},
{
"Name": "RiderShaderInfo",
"Type": "EditorNoCommandlet",
"LoadingPhase": "PostEngineInit"
},
{
"Name": "RiderLC",
"Type": "EditorNoCommandlet",
"LoadingPhase": "PostEngineInit"
},
{
"Name": "RiderDebuggerSupport",
"Type": "EditorNoCommandlet",
"LoadingPhase": "PreDefault",
"PlatformAllowList": [
"Win64"
],
"WhitelistPlatforms": [
"Win64"
]
}
]
}
================================================
FILE: src/cpp/RiderLink/Source/RD/RD.Build.cs
================================================
using System.IO;
using UnrealBuildTool;
public class RD : ModuleRules
{
public RD(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.Add("Core");
bUseRTTI = true;
#if UE_5_2_OR_LATER
bDisableStaticAnalysis = true;
#endif
#if UE_5_2_OR_LATER
IWYUSupport = IWYUSupport.KeepAsIs;
#else
bEnforceIWYU = false;
#endif
#if UE_5_6_OR_LATER
CppStandard = CppStandardVersion.Cpp20;
#elif UE_4_22_OR_LATER
CppStandard = CppStandardVersion.Cpp17;
#endif
#if UE_4_22_OR_LATER
PCHUsage = PCHUsageMode.NoPCHs;
#else
PCHUsage = PCHUsageMode.NoSharedPCHs;
#endif
#if UE_5_6_OR_LATER
CppCompileWarningSettings.ShadowVariableWarningLevel = WarningLevel.Off;
#elif UE_4_24_OR_LATER
ShadowVariableWarningLevel = WarningLevel.Off;
#else
bEnableShadowVariableWarnings = false;
#endif
#if UE_4_24_OR_LATER
bUseUnity = false;
#else
bFasterWithoutUnity = true;
#endif
PublicDefinitions.Add("_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("_WINSOCK_DEPRECATED_NO_WARNINGS");
PublicDefinitions.Add("_CRT_SECURE_NO_WARNINGS");
PublicDefinitions.Add("_CRT_NONSTDC_NO_DEPRECATE");
PublicDefinitions.Add("SPDLOG_WCHAR_FILENAMES");
PublicDefinitions.Add("SPDLOG_WCHAR_TO_UTF8_SUPPORT");
PrivateDefinitions.Add("WIN32_LEAN_AND_MEAN");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDefinitions.Add("_DARWIN");
}
// Common dependencies
PrivateDefinitions.Add("rd_framework_cpp_EXPORTS");
PrivateDefinitions.Add("rd_core_cpp_EXPORTS");
PrivateDefinitions.Add("spdlog_EXPORTS");
PrivateDefinitions.Add("FMT_EXPORT");
PrivateDefinitions.Add("_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR");
PublicDefinitions.Add("SPDLOG_NO_EXCEPTIONS");
PublicDefinitions.Add("SPDLOG_COMPILED_LIB");
PublicDefinitions.Add("SPDLOG_SHARED_LIB");
PublicDefinitions.Add(
"nssv_CONFIG_SELECT_STRING_VIEW=nssv_STRING_VIEW_NONSTD");
PublicDefinitions.Add("FMT_SHARED");
string[] Paths =
{
"src", "src/rd_core_cpp", "src/rd_core_cpp/src/main"
, "src/rd_framework_cpp", "src/rd_framework_cpp/src/main"
, "src/rd_framework_cpp/src/main/util", "src/rd_gen_cpp/src"
, "thirdparty", "thirdparty/ordered-map/include"
, "thirdparty/optional/tl", "thirdparty/variant/include"
, "thirdparty/string-view-lite/include", "thirdparty/spdlog/include"
, "thirdparty/clsocket/src", "thirdparty/CTPL/include", "thirdparty/utf-cpp/include"
};
foreach (var Item in Paths)
{
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, Item));
}
}
}
================================================
FILE: src/cpp/RiderLink/Source/RD/RD.cpp
================================================
#include "RD.h"
#include <Modules/ModuleManager.h>
#define LOCTEXT_NAMESPACE "RD"
DEFINE_LOG_CATEGORY(FLogRDModule);
IMPLEMENT_MODULE(FRDModule, RD);
#undef LOCTEXT_NAMESPACE
================================================
FILE: src/cpp/RiderLink/Source/RD/RD.h
================================================
// Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "Logging/LogMacros.h"
#include "Logging/LogVerbosity.h"
#include "Modules/ModuleInterface.h"
DECLARE_LOG_CATEGORY_EXTERN(FLogRDModule, Log, All);
class FRDModule : public IModuleInterface
{
public:
FRDModule() = default;
~FRDModule() = default;
};
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/rd_core_export.h
================================================
#ifndef RD_CORE_API_H
#define RD_CORE_API_H
#if defined(_WIN32)
#ifdef RD_CORE_STATIC_DEFINE
# define RD_CORE_API
# define RD_CORE_NO_EXPORT
#else
# ifndef RD_CORE_API
# ifdef rd_core_cpp_EXPORTS
/* We are building this library */
# define RD_CORE_API __declspec(dllexport)
# else
/* We are using this library */
# define RD_CORE_API __declspec(dllimport)
# endif
# endif
# ifndef RD_CORE_NO_EXPORT
# define RD_CORE_NO_EXPORT
# endif
#endif
#ifndef RD_CORE_DEPRECATED
# define RD_CORE_DEPRECATED __declspec(deprecated)
#endif
#ifndef RD_CORE_DEPRECATED_EXPORT
# define RD_CORE_DEPRECATED_EXPORT RD_CORE_API RD_CORE_DEPRECATED
#endif
#ifndef RD_CORE_DEPRECATED_NO_EXPORT
# define RD_CORE_DEPRECATED_NO_EXPORT RD_CORE_NO_EXPORT RD_CORE_DEPRECATED
#endif
#if 0 /* DEFINE_NO_DEPRECATED */
# ifndef RD_CORE_NO_DEPRECATED
# define RD_CORE_NO_DEPRECATED
# endif
#endif
#endif
#if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__)
#ifdef RD_CORE_STATIC_DEFINE
# define RD_CORE_API
# define RD_CORE_NO_EXPORT
#else
# ifndef RD_CORE_API
# ifdef rd_core_cpp_EXPORTS
/* We are building this library */
# define RD_CORE_API __attribute__((visibility("default")))
# else
/* We are using this library */
# define RD_CORE_API __attribute__((visibility("default")))
# endif
# endif
# ifndef RD_CORE_NO_EXPORT
# define RD_CORE_NO_EXPORT __attribute__((visibility("hidden")))
# endif
#endif
#ifndef RD_CORE_DEPRECATED
# define RD_CORE_DEPRECATED __attribute__ ((__deprecated__))
#endif
#ifndef RD_CORE_DEPRECATED_EXPORT
# define RD_CORE_DEPRECATED_EXPORT RD_CORE_API RD_CORE_DEPRECATED
#endif
#ifndef RD_CORE_DEPRECATED_NO_EXPORT
# define RD_CORE_DEPRECATED_NO_EXPORT RD_CORE_NO_EXPORT RD_CORE_DEPRECATED
#endif
#if 0 /* DEFINE_NO_DEPRECATED */
# ifndef RD_CORE_NO_DEPRECATED
# define RD_CORE_NO_DEPRECATED
# endif
#endif
#endif
#endif /* RD_CORE_API_H */
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/Lifetime.cpp
================================================
#include "Lifetime.h"
#include <memory>
#include <thirdparty.hpp>
#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_color_sinks.h>
namespace rd
{
/*thread_local */ Lifetime::Allocator Lifetime::allocator;
LifetimeImpl* Lifetime::operator->() const
{
return ptr.operator->();
}
std::once_flag onceFlag;
Lifetime::Lifetime(bool is_eternal) : ptr(std::allocate_shared<LifetimeImpl, Allocator>(allocator, is_eternal))
{
std::call_once(onceFlag, [] {
spdlog::set_default_logger(spdlog::stderr_color_mt<spdlog::synchronous_factory>("default", spdlog::color_mode::automatic));
});
}
Lifetime Lifetime::create_nested() const
{
Lifetime lw(false);
ptr->attach_nested(lw.ptr);
return lw;
}
Lifetime const& Lifetime::Eternal()
{
static Lifetime ETERNAL(true);
return ETERNAL;
}
bool operator==(Lifetime const& lw1, Lifetime const& lw2)
{
return lw1.ptr == lw2.ptr;
}
bool operator!=(Lifetime const& lw1, Lifetime const& lw2)
{
return !(lw1 == lw2);
}
} // namespace rd
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/Lifetime.h
================================================
#ifndef RD_CPP_CORE_LIFETIMEWRAPPER_H
#define RD_CPP_CORE_LIFETIMEWRAPPER_H
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4251)
#endif
#include "LifetimeImpl.h"
#include <std/hash.h>
#include <memory>
#include <rd_core_export.h>
namespace rd
{
class Lifetime;
template <>
struct RD_CORE_API hash<Lifetime>
{
size_t operator()(const Lifetime& value) const noexcept;
};
class RD_CORE_API Lifetime final
{
private:
using Allocator = std::allocator<LifetimeImpl>;
static /*thread_local */ Allocator allocator;
friend class LifetimeDefinition;
friend struct hash<Lifetime>;
std::shared_ptr<LifetimeImpl> ptr;
public:
static Lifetime const& Eternal();
// region ctor/dtor
Lifetime(Lifetime const& other) = default;
Lifetime& operator=(Lifetime const& other) = default;
Lifetime(Lifetime&& other) noexcept = default;
Lifetime& operator=(Lifetime&& other) noexcept = default;
~Lifetime() = default;
// endregion
friend bool RD_CORE_API operator==(Lifetime const& lw1, Lifetime const& lw2);
friend bool RD_CORE_API operator!=(Lifetime const& lw1, Lifetime const& lw2);
explicit Lifetime(bool is_eternal = false);
LifetimeImpl* operator->() const;
Lifetime create_nested() const;
};
inline size_t hash<Lifetime>::operator()(const Lifetime& value) const noexcept
{
return hash<std::shared_ptr<LifetimeImpl> >()(value.ptr);
}
} // namespace rd
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
#endif // RD_CPP_CORE_LIFETIMEWRAPPER_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeDefinition.cpp
================================================
#include "LifetimeDefinition.h"
#include <spdlog/spdlog.h>
namespace rd
{
LifetimeDefinition::LifetimeDefinition(bool eternaled) : eternaled(eternaled), lifetime(eternaled)
{
}
LifetimeDefinition::LifetimeDefinition(const Lifetime& parent) : LifetimeDefinition(false)
{
parent->attach_nested(lifetime.ptr);
}
bool LifetimeDefinition::is_terminated() const
{
return lifetime->is_terminated();
}
void LifetimeDefinition::terminate()
{
lifetime->terminate();
}
bool LifetimeDefinition::is_eternal() const
{
return lifetime->is_eternal();
}
namespace
{
LifetimeDefinition ETERNAL(true);
}
std::shared_ptr<LifetimeDefinition> LifetimeDefinition::get_shared_eternal()
{
return std::shared_ptr<LifetimeDefinition>(&ETERNAL, [](LifetimeDefinition* /*ld*/) {});
}
LifetimeDefinition::~LifetimeDefinition()
{
if (lifetime.ptr != nullptr)
{ // wasn't moved
if (!is_eternal())
{
if (!lifetime->is_terminated())
{
lifetime->terminate();
}
}
}
}
} // namespace rd
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeDefinition.h
================================================
#ifndef RD_CPP_CORE_LIFETIME_DEFINITION_H
#define RD_CPP_CORE_LIFETIME_DEFINITION_H
#include "util/core_traits.h"
#include "LifetimeImpl.h"
#include "Lifetime.h"
#include <functional>
#include <type_traits>
#include <rd_core_export.h>
namespace rd
{
class RD_CORE_API LifetimeDefinition
{
private:
friend class SequentialLifetimes;
bool eternaled = false;
public:
Lifetime lifetime;
explicit LifetimeDefinition(bool is_eternal = false);
explicit LifetimeDefinition(const Lifetime& parent);
LifetimeDefinition(LifetimeDefinition const& other) = delete;
LifetimeDefinition& operator=(LifetimeDefinition const& other) = delete;
LifetimeDefinition(LifetimeDefinition&& other) = default;
LifetimeDefinition& operator=(LifetimeDefinition&& other) = default;
virtual ~LifetimeDefinition();
// static std::shared_ptr<LifetimeDefinition> eternal;
static std::shared_ptr<LifetimeDefinition> get_shared_eternal();
bool is_terminated() const;
bool is_eternal() const;
void terminate();
template <typename F>
static auto use(F&& block) -> typename util::result_of_t<F(Lifetime)>
{
LifetimeDefinition definition(false);
Lifetime lw = definition.lifetime.create_nested();
return block(lw);
}
};
} // namespace rd
#endif // RD_CPP_CORE_LIFETIME_DEFINITION_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeImpl.cpp
================================================
#include "LifetimeImpl.h"
#include <utility>
namespace rd
{
#if __cplusplus < 201703L
LifetimeImpl::counter_t LifetimeImpl::get_id = 0;
#endif
LifetimeImpl::LifetimeImpl(bool is_eternal) : eternaled(is_eternal), id(LifetimeImpl::get_id++)
{
}
void LifetimeImpl::terminate()
{
if (is_eternal())
return;
terminated = true;
// region thread-safety section
actions_t actions_copy;
{
std::lock_guard<decltype(actions_lock)> guard(actions_lock);
actions_copy = std::move(actions);
actions.clear();
}
// endregion
for (auto it = actions_copy.rbegin(); it != actions_copy.rend(); ++it)
{
it->second();
}
}
bool LifetimeImpl::is_terminated() const
{
return terminated;
}
bool LifetimeImpl::is_eternal() const
{
return eternaled;
}
void LifetimeImpl::attach_nested(std::shared_ptr<LifetimeImpl> nested)
{
if (nested->is_terminated() || is_eternal())
return;
std::function<void()> action = [nested] { nested->terminate(); };
counter_t action_id = add_action(action);
nested->add_action([this, id = action_id] { actions.erase(id); });
}
LifetimeImpl::~LifetimeImpl()
{
/*if (!is_eternal() && !is_terminated()) {
spdlog::error("forget to terminate lifetime with id: {}", to_string(id));
terminate();
}*/
}
} // namespace rd
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeImpl.h
================================================
#ifndef RD_CPP_CORE_LIFETIME_H
#define RD_CPP_CORE_LIFETIME_H
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4251)
#endif
#include <std/hash.h>
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <atomic>
#include <utility>
#include <thirdparty.hpp>
#include <rd_core_export.h>
namespace rd
{
class RD_CORE_API LifetimeImpl final
{
public:
friend class LifetimeDefinition;
friend class Lifetime;
using counter_t = int32_t;
private:
bool eternaled = false;
std::atomic<bool> terminated{false};
counter_t id = 0;
counter_t action_id_in_map = 0;
using actions_t = ordered_map<int, std::function<void()>, rd::hash<int>>;
actions_t actions;
void terminate();
std::mutex actions_lock;
public:
// region ctor/dtor
explicit LifetimeImpl(bool is_eternal = false);
LifetimeImpl(LifetimeImpl const& other) = delete;
~LifetimeImpl();
// endregion
template <typename F>
counter_t add_action(F&& action)
{
std::lock_guard<decltype(actions_lock)> guard(actions_lock);
if (is_eternal())
{
return -1;
}
if (is_terminated())
{
throw std::invalid_argument("Already Terminated");
}
actions[action_id_in_map] = std::forward<F>(action);
return action_id_in_map++;
}
void remove_action(counter_t i)
{
std::lock_guard<decltype(actions_lock)> guard(actions_lock);
actions.erase(i);
}
#if __cplusplus >= 201703L
static inline counter_t get_id = 0;
#else
static counter_t get_id;
#endif
template <typename F, typename G>
void bracket(F&& opening, G&& closing)
{
if (is_terminated())
return;
opening();
add_action(std::forward<G>(closing));
}
bool is_terminated() const;
bool is_eternal() const;
void attach_nested(std::shared_ptr<LifetimeImpl> nested);
};
} // namespace rd
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
#endif // RD_CPP_CORE_LIFETIME_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/SequentialLifetimes.cpp
================================================
#include "SequentialLifetimes.h"
namespace rd
{
SequentialLifetimes::SequentialLifetimes(Lifetime parent_lifetime) : parent_lifetime(std::move(parent_lifetime))
{
this->parent_lifetime->add_action([this] { set_current_lifetime(LifetimeDefinition::get_shared_eternal()); });
}
Lifetime SequentialLifetimes::next()
{
std::shared_ptr<LifetimeDefinition> new_def = std::make_shared<LifetimeDefinition>(parent_lifetime);
set_current_lifetime(new_def);
return current_def->lifetime;
}
void SequentialLifetimes::terminate_current()
{
set_current_lifetime(LifetimeDefinition::get_shared_eternal());
}
bool SequentialLifetimes::is_terminated() const
{
return current_def->is_eternal() || current_def->is_terminated();
}
void SequentialLifetimes::set_current_lifetime(std::shared_ptr<LifetimeDefinition> new_def)
{
std::shared_ptr<LifetimeDefinition> prev = current_def;
current_def = new_def;
prev->terminate();
}
} // namespace rd
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/SequentialLifetimes.h
================================================
#ifndef RD_CPP_CORE_SEQUENTIAL_LIFETIMES_H
#define RD_CPP_CORE_SEQUENTIAL_LIFETIMES_H
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4251)
#endif
#include "LifetimeDefinition.h"
#include "Lifetime.h"
#include <rd_core_export.h>
namespace rd
{
class RD_CORE_API SequentialLifetimes
{
private:
std::shared_ptr<LifetimeDefinition> current_def = LifetimeDefinition::get_shared_eternal();
Lifetime parent_lifetime;
public:
// region ctor/dtor
SequentialLifetimes() = delete;
SequentialLifetimes(SequentialLifetimes const&) = delete;
SequentialLifetimes& operator=(SequentialLifetimes const&) = delete;
SequentialLifetimes(SequentialLifetimes&&) = delete;
SequentialLifetimes& operator=(SequentialLifetimes&&) = delete;
explicit SequentialLifetimes(Lifetime parent_lifetime);
// endregion
Lifetime next();
void terminate_current();
bool is_terminated() const;
void set_current_lifetime(std::shared_ptr<LifetimeDefinition> new_def);
};
} // namespace rd
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
#endif // RD_CPP_CORE_SEQUENTIAL_LIFETIMES_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/Property.h
================================================
#ifndef RD_CPP_CORE_PROPERTY_H
#define RD_CPP_CORE_PROPERTY_H
#include "base/IProperty.h"
#include "reactive/base/SignalX.h"
#include <util/core_util.h>
namespace rd
{
/**
* \brief complete class which has \a Property<T> 's properties.
* \tparam T type of stored value (may be abstract)
*/
template <typename T>
class Property : public IProperty<T>
{
using WT = typename IProperty<T>::WT;
public:
// region ctor/dtor
Property() = default;
Property(Property&& other) = default;
Property& operator=(Property&& other) = default;
virtual ~Property() = default;
template <typename F>
explicit Property(F&& value) : IProperty<T>(std::forward<F>(value))
{
}
// endregion
T const& get() const override
{
RD_ASSERT_THROW_MSG(this->has_value(), "get of uninitialized value from property");
return *(this->value);
}
void set(WT new_value) const override
{
if (!this->has_value() || (this->get() != wrapper::get<T>(new_value)))
{
if (this->has_value())
{
this->before_change.fire(*(this->value));
}
this->value = std::move(new_value);
this->change.fire(*(this->value));
}
}
friend bool operator==(const Property& lhs, const Property& rhs)
{
return &lhs == &rhs;
}
friend bool operator!=(const Property& lhs, const Property& rhs)
{
return !(rhs == lhs);
}
friend std::string to_string(Property const& value)
{
return value.has_value() ? to_string(value.get()) : "empty property"s;
}
};
} // namespace rd
static_assert(std::is_move_constructible<rd::Property<int>>::value, "Is not move constructible from Property<int>");
#endif // RD_CPP_CORE_PROPERTY_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableList.h
================================================
#ifndef RD_CPP_CORE_VIEWABLELIST_H
#define RD_CPP_CORE_VIEWABLELIST_H
#include "base/IViewableList.h"
#include "reactive/base/SignalX.h"
#include "util/core_util.h"
#include <algorithm>
#include <iterator>
#include <utility>
namespace rd
{
/**
* \brief complete class which has @code IViewableList<T>'s properties
*/
template <typename T, typename A = allocator<T>>
class ViewableList : public IViewableList<T>
{
public:
using Event = typename IViewableList<T>::Event;
private:
using WA = typename std::allocator_traits<A>::template rebind_alloc<Wrapper<T>>;
using data_t = std::vector<Wrapper<T>, WA>;
mutable data_t list;
Signal<Event> change;
protected:
using WT = typename IViewableList<T>::WT;
const std::vector<Wrapper<T>>& getList() const override
{
return list;
}
public:
// region ctor/dtor
ViewableList() = default;
ViewableList(ViewableList&&) = default;
ViewableList& operator=(ViewableList&&) = default;
virtual ~ViewableList() = default;
// endregion
// region iterators
public:
class iterator
{
friend class ViewableList<T>;
typename data_t::iterator it_;
explicit iterator(const typename data_t::iterator& it) : it_(it)
{
}
public:
using iterator_category = std::random_access_iterator_tag;
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T const*;
using reference = T const&;
iterator(const iterator& other) = default;
iterator(iterator&& other) noexcept = default;
iterator& operator=(const iterator& other) = default;
iterator& operator=(iterator&& other) noexcept = default;
iterator& operator++()
{
++it_;
return *this;
}
iterator operator++(int)
{
auto it = *this;
++*this;
return it;
}
iterator& operator--()
{
--it_;
return *this;
}
iterator operator--(int)
{
auto it = *this;
--*this;
return it;
}
iterator& operator+=(difference_type delta)
{
it_ += delta;
return *this;
}
iterator& operator-=(difference_type delta)
{
it_ -= delta;
return *this;
}
iterator operator+(difference_type delta) const
{
auto it = *this;
return it += delta;
}
iterator operator-(difference_type delta) const
{
auto it = *this;
return it -= delta;
}
difference_type operator-(iterator const& other) const
{
return it_ - other.it_;
}
bool operator<(iterator const& other) const noexcept
{
return this->it_ < other.it_;
}
bool operator>(iterator const& other) const noexcept
{
return this->it_ > other.it_;
}
bool operator==(iterator const& other) const noexcept
{
return this->it_ == other.it_;
}
bool operator!=(iterator const& other) const noexcept
{
return !(*this == other);
}
bool operator<=(iterator const& other) const noexcept
{
return (this->it_ < other.it_) || (*this == other);
}
bool operator>=(iterator const& other) const noexcept
{
return (this->it_ > other.it_) || (*this == other);
}
reference operator*() noexcept
{
return **it_;
}
reference operator*() const noexcept
{
return **it_;
}
pointer operator->() noexcept
{
return (*it_).get();
}
pointer operator->() const noexcept
{
return (*it_).get();
}
};
using reverse_iterator = std::reverse_iterator<iterator>;
iterator begin() const
{
return iterator(list.begin());
}
iterator end() const
{
return iterator(list.end());
}
reverse_iterator rbegin() const
{
return reverse_iterator(end());
}
reverse_iterator rend() const
{
return reverse_iterator(begin());
}
// endregion
void advise(Lifetime lifetime, std::function<void(Event const&)> handler) const override
{
if (lifetime->is_terminated())
return;
change.advise(lifetime, handler);
for (int32_t i = 0; i < static_cast<int32_t>(size()); ++i)
{
handler(typename Event::Add(i, &(*list[i])));
}
}
bool add(WT element) const override
{
list.emplace_back(std::move(element));
change.fire(typename Event::Add(static_cast<int32_t>(size()) - 1, &(*list.back())));
return true;
}
bool add(size_t index, WT element) const override
{
list.emplace(list.begin() + index, std::move(element));
change.fire(typename Event::Add(static_cast<int32_t>(index), &(*list[index])));
return true;
}
WT removeAt(size_t index) const override
{
auto res = std::move(list[index]);
list.erase(list.begin() + index);
change.fire(typename Event::Remove(static_cast<int32_t>(index), &(*res)));
return wrapper::unwrap<T>(std::move(res));
}
bool remove(T const& element) const override
{
auto it = std::find_if(list.begin(), list.end(), [&element](auto const& p) { return *p == element; });
if (it == list.end())
{
return false;
}
ViewableList::removeAt(std::distance(list.begin(), it));
return true;
}
T const& get(size_t index) const override
{
return *list[index];
}
WT set(size_t index, WT element) const override
{
auto old_value = std::move(list[index]);
list[index] = Wrapper<T>(std::move(element));
change.fire(typename Event::Update(static_cast<int32_t>(index), &(*old_value), &(*list[index]))); //???
return wrapper::unwrap<T>(std::move(old_value));
}
bool addAll(size_t index, std::vector<WT> elements) const override
{
for (auto& element : elements)
{
ViewableList::add(index, std::move(element));
++index;
}
return true;
}
bool addAll(std::vector<WT> elements) const override
{
for (auto&& element : elements)
{
ViewableList::add(std::move(element));
}
return true;
}
void clear() const override
{
std::vector<Event> changes;
for (size_t i = size(); i > 0; --i)
{
changes.push_back(typename Event::Remove(static_cast<int32_t>(i - 1), &(*list[i - 1])));
}
for (auto const& e : changes)
{
change.fire(e);
}
list.clear();
}
bool removeAll(std::vector<WT> elements) const override
{
// TO-DO faster
// std::unordered_set<T> set(elements.begin(), elements.end());
bool res = false;
for (size_t i = list.size(); i > 0; --i)
{
auto const& x = list[i - 1];
if (std::count_if(elements.begin(), elements.end(),
[&x](auto const& elem) { return wrapper::TransparentKeyEqual<T>()(elem, x); }) > 0)
{
removeAt(i - 1);
res = true;
}
}
return res;
}
size_t size() const override
{
return list.size();
}
bool empty() const override
{
return list.empty();
}
};
} // namespace rd
static_assert(std::is_move_constructible<rd::ViewableList<int>>::value, "Is move constructible from ViewableList<int>");
#endif // RD_CPP_CORE_VIEWABLELIST_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableMap.h
================================================
#ifndef RD_CPP_CORE_VIEWABLE_MAP_H
#define RD_CPP_CORE_VIEWABLE_MAP_H
#include "base/IViewableMap.h"
#include "reactive/base/SignalX.h"
#include <util/core_util.h>
#include <std/unordered_map.h>
#include <thirdparty.hpp>
#include <iterator>
#include <utility>
namespace rd
{
/**
* \brief complete class which has @code IViewableMap<K, V>'s properties
*/
template <typename K, typename V, typename KA = std::allocator<K>, typename VA = std::allocator<V>>
class ViewableMap : public IViewableMap<K, V>
{
public:
using Event = typename IViewableMap<K, V>::Event;
private:
using WK = typename IViewableMap<K, V>::WK;
using WV = typename IViewableMap<K, V>::WV;
using OV = typename IViewableMap<K, V>::OV;
using PA = typename std::allocator_traits<VA>::template rebind_alloc<std::pair<Wrapper<K>, Wrapper<V>>>;
Signal<Event> change;
using data_t = ordered_map<Wrapper<K>, Wrapper<V>, wrapper::TransparentHash<K>, wrapper::TransparentKeyEqual<K>, PA>;
mutable data_t map;
public:
// region ctor/dtor
ViewableMap() = default;
ViewableMap(ViewableMap&&) = default;
ViewableMap& operator=(ViewableMap&&) = default;
virtual ~ViewableMap() = default;
// endregion
// region iterators
public:
class iterator
{
friend class ViewableMap<K, V>;
mutable typename data_t::iterator it_;
explicit iterator(const typename data_t::iterator& it) : it_(it)
{
}
public:
using iterator_category = typename data_t::iterator::iterator_category;
using key_type = K;
using value_type = V;
using difference_type = std::ptrdiff_t;
using reference = V const&;
using pointer = V const*;
iterator(const iterator& other) = default;
iterator(iterator&& other) noexcept = default;
iterator& operator=(const iterator& other) = default;
iterator& operator=(iterator&& other) noexcept = default;
iterator& operator++()
{
++it_;
return *this;
}
iterator operator++(int)
{
auto it = *this;
++*this;
return it;
}
iterator& operator--()
{
--it_;
return *this;
}
iterator operator--(int)
{
auto it = *this;
--*this;
return it;
}
iterator& operator+=(difference_type delta)
{
it_ += delta;
return *this;
}
iterator& operator-=(difference_type delta)
{
it_ -= delta;
return *this;
}
iterator operator+(difference_type delta) const
{
auto it = *this;
return it += delta;
}
iterator operator-(difference_type delta) const
{
auto it = *this;
return it -= delta;
}
difference_type operator-(iterator const& other) const
{
return it_ - other.it_;
}
bool operator<(iterator const& other) const noexcept
{
return this->it_ < other.it_;
}
bool operator>(iterator const& other) const noexcept
{
return this->it_ > other.it_;
}
bool operator==(iterator const& other) const noexcept
{
return this->it_ == other.it_;
}
bool operator!=(iterator const& other) const noexcept
{
return !(*this == other);
}
bool operator<=(iterator const& other) const noexcept
{
return (this->it_ < other.it_) || (*this == other);
}
bool operator>=(iterator const& other) const noexcept
{
return (this->it_ > other.it_) || (*this == other);
}
reference operator*() const noexcept
{
return *it_.value();
}
pointer operator->() const noexcept
{
return it_.value().get();
}
key_type const& key() const
{
return *it_.key();
}
value_type const& value() const
{
return *it_.value();
}
};
class reverse_iterator : public std::reverse_iterator<iterator>
{
using base_t = std::reverse_iterator<iterator>;
public:
using iterator_category = typename iterator::iterator_category;
using key_type = typename iterator::key_type;
using value_type = typename iterator::value_type;
using difference_type = typename iterator::difference_type;
using reference = typename iterator::reference;
using pointer = typename iterator::pointer;
reverse_iterator(const reverse_iterator& other) = default;
reverse_iterator& operator=(const reverse_iterator& other) = default;
explicit reverse_iterator(const iterator& other) : base_t(other){};
reverse_iterator& operator=(const iterator& other)
{
static_cast<base_t>(*this) = other;
};
key_type const& key() const
{
auto it = base_t::current;
return (--(it)).key();
}
value_type const& value() const
{
auto it = base_t::current;
return (--it).value();
}
};
iterator begin() const
{
return iterator(map.begin());
}
iterator end() const
{
return iterator(map.end());
}
reverse_iterator rbegin() const
{
return reverse_iterator(end());
}
reverse_iterator rend() const
{
return reverse_iterator(begin());
}
// endregion
void advise(Lifetime lifetime, std::function<void(Event const&)> handler) const override
{
change.advise(lifetime, handler);
/*for (auto const &[key, value] : map) {*/
for (auto const& it : map)
{
auto& key = it.first;
auto& value = it.second;
handler(Event(typename Event::Add(&(*key), &(*value))));
;
}
}
const V* get(K const& key) const override
{
auto it = map.find(key);
if (it == map.end())
{
return nullptr;
}
return &(*it->second);
}
const V* set(WK key, WV value) const override
{
if (map.count(key) == 0)
{
/*auto[it, success] = map.emplace(std::make_unique<K>(std::move(key)), std::make_unique<V>(std::move(value)));*/
auto node = map.emplace(std::move(key), std::move(value));
auto& it = node.first;
auto const& key_ptr = it->first;
auto const& value_ptr = it->second;
change.fire(typename Event::Add(&(*key_ptr), &(*value_ptr)));
return nullptr;
}
else
{
auto it = map.find(key);
auto const& key_ptr = it->first;
auto const& value_ptr = it->second;
if (*value_ptr != wrapper::get<V>(value))
{ // TO-DO more effective
Wrapper<V> old_value = std::move(map.at(key));
map.at(key_ptr) = Wrapper<V>(std::move(value));
change.fire(typename Event::Update(&(*key_ptr), &(*old_value), &(*value_ptr)));
}
return &*(value_ptr);
}
}
OV remove(K const& key) const override
{
if (map.count(key) > 0)
{
Wrapper<V> old_value = std::move(map.at(key));
change.fire(typename Event::Remove(&key, &(*old_value)));
map.erase(key);
return wrapper::unwrap<V>(std::move(old_value));
}
return nullopt;
}
void clear() const override
{
std::vector<Event> changes;
/*for (auto const &[key, value] : map) {*/
for (auto const& it : map)
{
changes.push_back(typename Event::Remove(&(*it.first), &(*it.second)));
}
for (auto const& it : changes)
{
change.fire(it);
}
map.clear();
}
size_t size() const override
{
return map.size();
}
bool empty() const override
{
return map.empty();
}
};
} // namespace rd
static_assert(std::is_move_constructible<rd::ViewableMap<int, int>>::value, "Is move constructible from ViewableMap<int, int>");
#endif // RD_CPP_CORE_VIEWABLE_MAP_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableSet.h
================================================
#ifndef RD_CPP_CORE_VIEWABLESET_H
#define RD_CPP_CORE_VIEWABLESET_H
#include "base/IViewableSet.h"
#include "reactive/base/SignalX.h"
#include <std/allocator.h>
#include <util/core_util.h>
namespace rd
{
/**
* \brief complete class which has @code IViewableSet<T>'s properties
* \tparam T
*/
template <typename T, typename A = allocator<T>>
class ViewableSet : public IViewableSet<T, A>
{
public:
using Event = typename IViewableSet<T>::Event;
using IViewableSet<T, A>::advise;
private:
using WT = typename IViewableSet<T, A>::WT;
using WA = typename std::allocator_traits<A>::template rebind_alloc<Wrapper<T>>;
Signal<Event> change;
using data_t = ordered_set<Wrapper<T>, wrapper::TransparentHash<T>, wrapper::TransparentKeyEqual<T>, WA>;
mutable data_t set;
public:
// region ctor/dtor
ViewableSet() = default;
ViewableSet(ViewableSet&&) = default;
ViewableSet& operator=(ViewableSet&&) = default;
virtual ~ViewableSet() = default;
// endregion
// region iterators
public:
class iterator
{
friend class ViewableSet<T>;
typename data_t::iterator it_;
explicit iterator(const typename data_t::iterator& it) : it_(it)
{
}
public:
using iterator_category = std::random_access_iterator_tag;
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T const*;
using reference = T const&;
iterator(const iterator& other) = default;
iterator(iterator&& other) noexcept = default;
iterator& operator=(const iterator& other) = default;
iterator& operator=(iterator&& other) noexcept = default;
iterator& operator++()
{
++it_;
return *this;
}
iterator operator++(int)
{
auto it = *this;
++*this;
return it;
}
iterator& operator--()
{
--it_;
return *this;
}
iterator operator--(int)
{
auto it = *this;
--*this;
return it;
}
iterator& operator+=(difference_type delta)
{
it_ += delta;
return *this;
}
iterator& operator-=(difference_type delta)
{
it_ -= delta;
return *this;
}
iterator operator+(difference_type delta) const
{
auto it = *this;
return it += delta;
}
iterator operator-(difference_type delta) const
{
auto it = *this;
return it -= delta;
}
difference_type operator-(iterator const& other) const
{
return it_ - other.it_;
}
bool operator<(iterator const& other) const noexcept
{
return this->it_ < other.it_;
}
bool operator>(iterator const& other) const noexcept
{
return this->it_ > other.it_;
}
bool operator==(iterator const& other) const noexcept
{
return this->it_ == other.it_;
}
bool operator!=(iterator const& other) const noexcept
{
return !(*this == other);
}
bool operator<=(iterator const& other) const noexcept
{
return (this->it_ < other.it_) || (*this == other);
}
bool operator>=(iterator const& other) const noexcept
{
return (this->it_ > other.it_) || (*this == other);
}
reference operator*() const noexcept
{
return **it_;
}
pointer operator->() const noexcept
{
return (*it_).get();
}
};
using reverse_iterator = std::reverse_iterator<iterator>;
iterator begin() const
{
return iterator(set.begin());
}
iterator end() const
{
return iterator(set.end());
}
reverse_iterator rbegin() const
{
return reverse_iterator(end());
}
reverse_iterator rend() const
{
return reverse_iterator(begin());
}
// endregion
bool add(WT element) const override
{
/*auto const &[it, success] = set.emplace(std::make_unique<T>(std::move(element)));*/
auto const& it = set.emplace(std::move(element));
if (!it.second)
{
return false;
}
change.fire(Event(AddRemove::ADD, &(wrapper::get<T>(*it.first))));
return true;
}
bool addAll(std::vector<WT> elements) const override
{
for (auto&& element : elements)
{
ViewableSet::add(std::move(element));
}
return true;
}
void clear() const override
{
std::vector<Event> changes;
for (auto const& element : set)
{
changes.push_back(Event(AddRemove::REMOVE, &(*element)));
}
for (auto const& e : changes)
{
change.fire(e);
}
set.clear();
}
bool remove(T const& element) const override
{
if (!ViewableSet::contains(element))
{
return false;
}
auto it = set.find(element);
change.fire(Event(AddRemove::REMOVE, &(wrapper::get<T>(*it))));
set.erase(it);
return true;
}
void advise(Lifetime lifetime, std::function<void(Event const&)> handler) const override
{
for (auto const& x : set)
{
handler(Event(AddRemove::ADD, &(*x)));
}
change.advise(lifetime, handler);
}
size_t size() const override
{
return set.size();
}
bool contains(T const& element) const override
{
return set.count(element) > 0;
}
bool empty() const override
{
return set.empty();
}
template <typename... Args>
bool emplace_add(Args&&... args) const
{
return add(WT{std::forward<Args>(args)...});
}
};
} // namespace rd
static_assert(std::is_move_constructible<rd::ViewableSet<int>>::value, "Is move constructible from ViewableSet<int>");
#endif // RD_CPP_CORE_VIEWABLESET_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IProperty.h
================================================
#ifndef RD_CPP_IPROPERTY_H
#define RD_CPP_IPROPERTY_H
#include "SignalX.h"
#include "IPropertyBase.h"
#include <lifetime/Lifetime.h>
#include <types/wrapper.h>
#include <functional>
namespace rd
{
/**
* \brief A mutable property.
* \tparam T type of stored value (may be abstract)
*/
template <typename T>
class IProperty : public IPropertyBase<T>
{
protected:
using WT = typename IPropertyBase<T>::WT;
public:
// region ctor/dtor
IProperty() = default;
IProperty(IProperty&& other) = default;
IProperty& operator=(IProperty&& other) = default;
explicit IProperty(T const& value) : IPropertyBase<T>(value)
{
}
template <typename F>
explicit IProperty(F&& value) : IPropertyBase<T>(std::forward<F>(value))
{
}
virtual ~IProperty() = default;
// endregion
virtual T const& get() const = 0;
private:
void advise0(Lifetime lifetime, std::function<void(T const&)> handler, Signal<T> const& signal) const
{
if (lifetime->is_terminated())
{
return;
}
signal.advise(lifetime, handler);
if (this->has_value())
{
handler(this->get());
}
}
void advise_before(Lifetime lifetime, std::function<void(T const&)> handler) const override
{
advise0(lifetime, handler, this->before_change);
}
public:
void advise(Lifetime lifetime, std::function<void(T const&)> handler) const override
{
advise0(lifetime, std::move(handler), this->change);
}
/**
* \brief set value of type T or derived type to it.
*/
virtual void set(value_or_wrapper<T>) const = 0;
/**
* \brief construct value of type T and delegate call to set
*/
template <typename... Args>
void emplace(Args&&... args) const
{
set(value_or_wrapper<T>{std::forward<Args>(args)...});
}
void set_if_empty(WT new_value) const
{
if (!this->has_value())
{
set(std::move(new_value));
}
}
};
} // namespace rd
#endif // RD_CPP_IPROPERTY_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IPropertyBase.h
================================================
#ifndef RD_CPP_IPROPERTYBASE_H
#define RD_CPP_IPROPERTYBASE_H
#include "interfaces.h"
#include "SignalX.h"
#include <types/wrapper.h>
#include <lifetime/SequentialLifetimes.h>
#include "thirdparty.hpp"
namespace rd
{
template <typename T>
class IPropertyBase : public ISource<T>, public IViewable<T>
{
protected:
mutable property_storage<T> value;
Signal<T> change, before_change;
using WT = value_or_wrapper<T>;
public:
bool has_value() const
{
return (bool) (value);
}
// region ctor/dtor
IPropertyBase() = default;
IPropertyBase(IPropertyBase&& other) = default;
IPropertyBase& operator=(IPropertyBase&& other) = default;
template <typename F>
explicit IPropertyBase(F&& value) : value(std::forward<F>(value))
{
}
virtual ~IPropertyBase() = default;
// endregion
virtual void advise_before(Lifetime lifetime, std::function<void(T const&)> handler) const = 0;
void view(Lifetime lifetime, std::function<void(Lifetime, T const&)> handler) const override
{
if (lifetime->is_terminated())
return;
Lifetime lf = lifetime.create_nested();
std::shared_ptr<SequentialLifetimes> seq = std::make_shared<SequentialLifetimes>(lf);
this->advise_before(lf, [lf, seq](T const& /*v*/) {
if (!lf->is_terminated())
{
seq->terminate_current();
}
});
this->advise(lf, [lf, seq, handler](T const& v) {
if (!lf->is_terminated())
{
handler(seq->next(), v);
}
});
}
};
} // namespace rd
#endif // RD_CPP_IPROPERTYBASE_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableList.h
================================================
#ifndef RD_CPP_IVIEWABLELIST_H
#define RD_CPP_IVIEWABLELIST_H
#include "interfaces.h"
#include "viewable_collections.h"
#include <lifetime/LifetimeDefinition.h>
#include <util/overloaded.h>
#include <types/wrapper.h>
#include <std/unordered_map.h>
#include <vector>
#include <utility>
#include <algorithm>
#include "thirdparty.hpp"
namespace rd
{
namespace detail
{
template <typename T>
class ListEvent
{
public:
class Add
{
public:
int32_t index;
T const* new_value;
Add(int32_t index, T const* new_value) : index(index), new_value(new_value)
{
}
};
class Update
{
public:
int32_t index;
T const* old_value;
T const* new_value;
Update(int32_t index, T const* old_value, T const* new_value) : index(index), old_value(old_value), new_value(new_value)
{
}
};
class Remove
{
public:
int32_t index;
T const* old_value;
Remove(int32_t index, T const* old_value) : index(index), old_value(old_value)
{
}
};
variant<Add, Update, Remove> v;
ListEvent(Add x) : v(x)
{
}
ListEvent(Update x) : v(x)
{
}
ListEvent(Remove x) : v(x)
{
}
int32_t get_index() const
{
return visit(util::make_visitor([](Add const& e) { return e.index; }, [](Update const& e) { return e.index; },
[](Remove const& e) { return e.index; }),
v);
}
T const* get_new_value() const
{
return visit(util::make_visitor([](Add const& e) { return e.new_value; }, [](Update const& e) { return e.new_value; },
[](Remove const& /*e*/) { return static_cast<T const*>(nullptr); }),
v);
}
friend std::string to_string(ListEvent const& e)
{
std::string res = visit(
util::make_visitor(
[](typename ListEvent::Add const& e) { return "Add " + std::to_string(e.index) + ":" + to_string(*e.new_value); },
[](typename ListEvent::Update const& e) {
return "Update " + std::to_string(e.index) + ":" +
// to_string(e.old_value) + ":" +
to_string(*e.new_value);
},
[](typename ListEvent::Remove const& e) { return "Remove " + std::to_string(e.index); }),
e.v);
return res;
}
};
} // namespace detail
/**
* \brief A list allowing its contents to be observed.
* \tparam T type of stored values (may be abstract)
*/
template <typename T>
class IViewableList : public IViewable<std::pair<size_t, T const*>>, public ISource<detail::ListEvent<T>>
{
protected:
using WT = value_or_wrapper<T>;
public:
/**
* \brief Represents an addition, update or removal of an element in the list.
*/
using Event = typename detail::ListEvent<T>;
protected:
mutable rd::unordered_map<Lifetime, std::vector<LifetimeDefinition>> lifetimes;
public:
// region ctor/dtor
IViewableList() = default;
IViewableList(IViewableList&&) = default;
IViewableList& operator=(IViewableList&&) = default;
virtual ~IViewableList() = default;
// endregion
/**
* \brief Adds a subscription to additions and removals of list elements. When a list element is updated,
* the [handler] is called twice: to report the removal of the old element and the addition of the new one.
* \param lifetime lifetime of subscription.
* \param handler to be called.
*/
void advise_add_remove(Lifetime lifetime, std::function<void(AddRemove, size_t, T const&)> handler) const
{
advise(lifetime, [handler](Event e) {
visit(util::make_visitor([handler](typename Event::Add const& e) { handler(AddRemove::ADD, e.index, *e.new_value); },
[handler](typename Event::Update const& e) {
handler(AddRemove::REMOVE, e.index, *e.old_value);
handler(AddRemove::ADD, e.index, *e.new_value);
},
[handler](typename Event::Remove const& e) { handler(AddRemove::REMOVE, e.index, *e.old_value); }),
e.v);
});
}
/**
* \brief Adds a subscription to changes of the contents of the list.
* \param lifetime lifetime of subscription.
* \param handler to be called.
*/
void view(Lifetime lifetime, std::function<void(Lifetime lifetime, std::pair<size_t, T const*> const&)> handler) const override
{
view(lifetime, [handler](Lifetime lt, size_t idx, T const& v) { handler(lt, std::make_pair(idx, &v)); });
}
/**
* \brief @see view above
*/
void view(Lifetime lifetime, std::function<void(Lifetime, size_t, T const&)> handler) const
{
advise_add_remove(lifetime, [this, lifetime, handler](AddRemove kind, size_t idx, T const& value) {
switch (kind)
{
case AddRemove::ADD:
{
LifetimeDefinition def(lifetime);
std::vector<LifetimeDefinition>& v = lifetimes[lifetime];
auto it = v.emplace(v.begin() + idx, std::move(def));
handler(it->lifetime, idx, value);
break;
}
case AddRemove::REMOVE:
{
LifetimeDefinition def = std::move(lifetimes.at(lifetime)[idx]);
std::vector<LifetimeDefinition>& v = lifetimes.at(lifetime);
v.erase(v.begin() + idx);
def.terminate();
break;
}
}
});
}
void advise(Lifetime lifetime, std::function<void(Event const&)> handler) const override = 0;
virtual bool add(WT element) const = 0;
virtual bool add(size_t index, WT element) const = 0;
virtual WT removeAt(size_t index) const = 0;
virtual bool remove(T const& element) const = 0;
virtual T const& get(size_t index) const = 0;
virtual WT set(size_t index, WT element) const = 0;
virtual bool addAll(size_t index, std::vector<WT> elements) const = 0;
virtual bool addAll(std::vector<WT> elements) const = 0;
virtual void clear() const = 0;
virtual bool removeAll(std::vector<WT> elements) const = 0;
virtual size_t size() const = 0;
virtual bool empty() const = 0;
template <typename... Args>
bool emplace_add(Args&&... args) const
{
return add(WT{std::forward<Args>(args)...});
}
template <typename... Args>
bool emplace_add(size_t index, Args&&... args) const
{
return add(index, WT{std::forward<Args>(args)...});
}
template <typename... Args>
WT emplace_set(size_t index, Args&&... args) const
{
return set(index, WT{std::forward<Args>(args)...});
}
template <typename U>
friend typename std::enable_if<(!std::is_abstract<U>::value), std::vector<U>>::type convert_to_list(
IViewableList<U> const& list);
protected:
virtual const std::vector<Wrapper<T>>& getList() const = 0;
};
template <typename T>
typename std::enable_if<(!std::is_abstract<T>::value), std::vector<T>>::type convert_to_list(IViewableList<T> const& list)
{
std::vector<T> res(list.size());
std::transform(list.getList().begin(), list.getList().end(), res.begin(), [](Wrapper<T> const& ptr) { return *ptr; });
return res;
}
} // namespace rd
static_assert(
std::is_move_constructible<rd::IViewableList<int>::Event>::value, "Is move constructible from IViewableList<int>::Event");
#endif // RD_CPP_IVIEWABLELIST_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableMap.h
================================================
#ifndef RD_CPP_IVIEWABLEMAP_H
#define RD_CPP_IVIEWABLEMAP_H
#include "lifetime/LifetimeDefinition.h"
#include "util/overloaded.h"
#include "interfaces.h"
#include "viewable_collections.h"
#include "util/core_util.h"
#include "std/unordered_map.h"
#include "thirdparty.hpp"
namespace rd
{
namespace detail
{
template <typename K, typename V>
class MapEvent
{
public:
class Add
{
public:
K const* key;
V const* new_value;
Add(K const* key, V const* new_value) : key(key), new_value(new_value)
{
}
};
class Update
{
public:
K const* key;
V const* old_value;
V const* new_value;
Update(K const* key, V const* old_value, V const* new_value) : key(key), old_value(old_value), new_value(new_value)
{
}
};
class Remove
{
public:
K const* key;
V const* old_value;
Remove(K const* key, V const* old_value) : key(key), old_value(old_value)
{
}
};
variant<Add, Update, Remove> v;
MapEvent(Add x) : v(x)
{
}
MapEvent(Update x) : v(x)
{
}
MapEvent(Remove x) : v(x)
{
}
K const* get_key() const
{
return visit(
util::make_visitor([](typename MapEvent::Add const& e) { return e.key; },
[](typename MapEvent::Update const& e) { return e.key; }, [](typename MapEvent::Remove const& e) { return e.key; }),
v);
}
V const* get_old_value() const
{
return visit(util::make_visitor([](typename MapEvent::Add const&) { return static_cast<V const*>(nullptr); },
[](typename MapEvent::Update const& e) { return e.old_value; },
[](typename MapEvent::Remove const& e) { e.old_value; }),
v);
}
V const* get_new_value() const
{
return visit(util::make_visitor([](typename MapEvent::Add const& e) { return e.new_value; },
[](typename MapEvent::Update const& e) { return e.new_value; },
[](typename MapEvent::Remove const& /*e*/) { return static_cast<V const*>(nullptr); }),
v);
}
friend std::string to_string(MapEvent const& e)
{
std::string res =
visit(util::make_visitor([](typename MapEvent::Add const& e)
-> std::string { return "Add " + to_string(*e.key) + ":" + to_string(*e.new_value); },
[](typename MapEvent::Update const& e) -> std::string {
return "Update " + to_string(*e.key) + ":" +
// to_string(e.old_value) + ":" +
to_string(*e.new_value);
},
[](typename MapEvent::Remove const& e) -> std::string { return "Remove " + to_string(*e.key); }),
e.v);
return res;
}
};
} // namespace detail
/**
* \brief A set allowing its contents to be observed.
* \tparam K type of stored keys (may be abstract)
* \tparam V type of stored values (may be abstract)
*/
template <typename K, typename V>
class IViewableMap : public IViewable<std::pair<K const*, V const*>>, public ISource<detail::MapEvent<K, V>>
{
protected:
using WK = value_or_wrapper<K>;
using WV = value_or_wrapper<V>;
using OV = opt_or_wrapper<V>;
mutable rd::unordered_map<Lifetime,
ordered_map<K const*, LifetimeDefinition, wrapper::TransparentHash<K>, wrapper::TransparentKeyEqual<K>>>
lifetimes;
public:
/**
* \brief Represents an addition, update or removal of an element in the map.
*/
using Event = typename detail::MapEvent<K, V>;
// region ctor/dtor
IViewableMap() = default;
IViewableMap(IViewableMap&&) = default;
IViewableMap& operator=(IViewableMap&&) = default;
virtual ~IViewableMap() = default;
// endregion
void view(Lifetime lifetime, std::function<void(Lifetime lifetime, std::pair<K const*, V const*> const&)
>
handler) const override
{
advise_add_remove(lifetime, [this, lifetime, handler](AddRemove kind, K const& key, V const& value) {
const std::pair<K const*, V const*> entry = std::make_pair(&key, &value);
switch (kind)
{
case AddRemove::ADD:
{
if (lifetimes[lifetime].count(key) == 0)
{
/*auto const &[it, inserted] = lifetimes[lifetime].emplace(key, LifetimeDefinition(lifetime));*/
auto const& pair = lifetimes[lifetime].emplace(&key, LifetimeDefinition(lifetime));
auto& it = pair.first;
auto& inserted = pair.second;
RD_ASSERT_MSG(inserted, "lifetime definition already exists in viewable map by key:" + to_string(key));
handler(it->second.lifetime, entry);
}
break;
}
case AddRemove::REMOVE:
{
RD_ASSERT_MSG(lifetimes.at(lifetime).count(key) > 0,
"attempting to remove non-existing lifetime in viewable map by key:" + to_string(key));
LifetimeDefinition def = std::move(lifetimes.at(lifetime).at(key));
lifetimes.at(lifetime).erase(key);
def.terminate();
break;
}
}
});
}
/**
* \brief Adds a subscription to additions and removals of map elements. When a map element is updated, the [handler]
* is called twice: to report the removal of the old element and the addition of the new one.
* \param lifetime lifetime of subscription.
* \param handler to be called.
*/
void advise_add_remove(Lifetime lifetime, std::function<void(AddRemove, K const&, V const&)
>
handler) const
{
advise(lifetime, [handler](Event e) {
visit(util::make_visitor([handler](typename Event::Add const& e) { handler(AddRemove::ADD, *e.key, *e.new_value); },
[handler](typename Event::Update const& e) {
handler(AddRemove::REMOVE, *e.key, *e.old_value);
handler(AddRemove::ADD, *e.key, *e.new_value);
},
[handler](typename Event::Remove const& e) { handler(AddRemove::REMOVE, *e.key, *e.old_value); }),
e.v);
});
}
/**
* \brief Adds a subscription to changes of the contents of the map, with the handler receiving keys and values
* as separate parameters.
*
* \details When [handler] is initially added, it is called receiving all keys and values currently in the map.
* Every time a key/value pair is added to the map, the [handler] is called receiving the new key and value.
* The [Lifetime] instance passed to the handler expires when the key/value pair is removed from the map.
*
* \param lifetime lifetime of subscription.
* \param handler to be called.
*/
void view(Lifetime lifetime, std::function<void(Lifetime, K const&, V const&)
>
handler) const
{
view(lifetime,
[handler](Lifetime lf, const std::pair<K const*, V const*> entry) { handler(lf, *entry.first, *entry.second); });
}
void advise(Lifetime lifetime, std::function<void(Event const&)> handler) const override = 0;
virtual const V* get(K const&) const = 0;
virtual const V* set(WK, WV) const = 0;
virtual OV remove(K const&) const = 0;
virtual void clear() const = 0;
virtual size_t size() const = 0;
virtual bool empty() const = 0;
template <typename... Args>
const V* emplace_set(WK wk, Args&&... args) const
{
return set(std::move(wk), WV{std::forward<Args>(args)...});
}
};
} // namespace rd
static_assert(std::is_move_constructible<rd::IViewableMap<int, int>::Event>::value,
"Is move constructible from IViewableMap<int, int>::Event");
#endif // RD_CPP_IVIEWABLEMAP_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableSet.h
================================================
#ifndef RD_CPP_IVIEWABLESET_H
#define RD_CPP_IVIEWABLESET_H
#include "interfaces.h"
#include "viewable_collections.h"
#include <lifetime/LifetimeDefinition.h>
#include <util/core_util.h>
#include <std/unordered_map.h>
#include <thirdparty.hpp>
namespace rd
{
namespace detail
{
template <typename T>
class SetEvent
{
public:
SetEvent(AddRemove kind, T const* value) : kind(kind), value(value)
{
}
AddRemove kind;
T const* value;
friend std::string to_string(SetEvent const& e)
{
return to_string(e.kind) + ":" + to_string(*e.value);
}
};
} // namespace detail
/**
* \brief A set allowing its contents to be observed.
* \tparam T type of stored values (may be abstract)
*/
template <typename T, typename A = allocator<T>>
class IViewableSet : public IViewable<T>, public ISource<detail::SetEvent<T>>
{
protected:
using WT = value_or_wrapper<T>;
mutable rd::unordered_map<Lifetime,
ordered_map<T const*, LifetimeDefinition, wrapper::TransparentHash<T>, wrapper::TransparentKeyEqual<T>>>
lifetimes;
public:
// region ctor/dtor
IViewableSet() = default;
IViewableSet(IViewableSet&&) = default;
IViewableSet& operator=(IViewableSet&&) = default;
virtual ~IViewableSet() = default;
// endregion
/**
* \brief Represents an addition or removal of an element in the set.
*/
using Event = typename detail::SetEvent<T>;
/**
* \brief Adds a subscription for additions and removals of set elements. When the subscription is initially
* added, [handler] is called with [AddRemove::Add] events for all elements currently in the set.
*
* \param lifetime lifetime of subscription.
* \param handler to be called.
*/
void advise(Lifetime lifetime, std::function<void(AddRemove, T const&)> handler) const
{
this->advise(lifetime, [handler](Event e) { handler(e.kind, *e.value); });
}
/**
* \brief Adds a subscription to changes of the contents of the set.
*
* \details When [handler] is initially added, it is called receiving all elements currently in the set.
* Every time an object is added to the set, the [handler] is called receiving the new element.
* The [Lifetime] instance passed to the handler expires when the element is removed from the set.
*
* \param lifetime
* \param handler
*/
void view(Lifetime lifetime, std::function<void(Lifetime, T const&)> handler) const override
{
advise(lifetime, [this, lifetime, handler](AddRemove kind, T const& key) {
switch (kind)
{
case AddRemove::ADD:
{
/*auto const &[it, inserted] = lifetimes[lifetime].emplace(key, LifetimeDefinition(lifetime));*/
auto const& it = lifetimes[lifetime].emplace(&key, lifetime);
RD_ASSERT_MSG(it.second, "lifetime definition already exists in viewable set by key:" + to_string(key));
handler(it.first->second.lifetime, key);
break;
}
case AddRemove::REMOVE:
{
RD_ASSERT_MSG(lifetimes.at(lifetime).count(key) > 0,
"attempting to remove non-existing lifetime in viewable set by key:" + to_string(key));
LifetimeDefinition def = std::move(lifetimes.at(lifetime).at(key));
lifetimes.at(lifetime).erase(key);
def.terminate();
break;
}
}
});
}
/**
* \brief Adds a subscription for additions and removals of set elements. When the subscription is initially
* added, [handler] is called with [AddRemove.Add] events for all elements currently in the set.
*
* \param lifetime lifetime of subscription.
* \param handler to be called.
*/
void advise(Lifetime lifetime, std::function<void(Event const&)> handler) const override = 0;
virtual bool add(WT) const = 0;
virtual bool addAll(std::vector<WT> elements) const = 0;
virtual void clear() const = 0;
virtual bool remove(T const&) const = 0;
virtual size_t size() const = 0;
virtual bool contains(T const&) const = 0;
virtual bool empty() const = 0;
template <typename... Args>
bool emplace_add(Args&&... args) const
{
return add(WT{std::forward<Args>(args)...});
}
};
} // namespace rd
static_assert(
std::is_move_constructible<rd::IViewableSet<int>::Event>::value, "Is move constructible from IViewableSet<int>::Event");
#endif // RD_CPP_IVIEWABLESET_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/SignalCookie.cpp
================================================
#include "SignalCookie.h"
#include <atomic>
namespace
{
std::atomic<int32_t> cookie;
}
void rd_signal_cookie_inc()
{
++cookie;
}
void rd_signal_cookie_dec()
{
--cookie;
}
int32_t rd_signal_cookie_get()
{
return cookie;
}
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/SignalCookie.h
================================================
#ifndef RD_CPP_SIGNALCOOKIE_H
#define RD_CPP_SIGNALCOOKIE_H
#include <cstdint>
#include <rd_core_export.h>
extern "C" void RD_CORE_API rd_signal_cookie_inc();
extern "C" void RD_CORE_API rd_signal_cookie_dec();
extern "C" int32_t RD_CORE_API rd_signal_cookie_get();
#endif // RD_CPP_SIGNALCOOKIE_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/SignalX.h
================================================
#ifndef RD_CPP_CORE_SIGNAL_H
#define RD_CPP_CORE_SIGNAL_H
#include "interfaces.h"
#include "SignalCookie.h"
#include <lifetime/Lifetime.h>
#include <util/core_util.h>
#include <utility>
#include <functional>
#include <atomic>
namespace rd
{
/**
* \brief complete class which has \a Signal<T> 's properties
*/
template <typename T>
class Signal final : public ISignal<T>
{
private:
using WT = typename ISignal<T>::WT;
class Event
{
private:
std::function<void(T const&)> action;
Lifetime lifetime;
public:
// region ctor/dtor
Event() = delete;
template <typename F>
Event(F&& action, Lifetime lifetime) : action(std::forward<F>(action)), lifetime(lifetime)
{
}
Event(Event&&) = default;
// endregion
bool is_alive() const
{
return !lifetime->is_terminated();
}
void execute_if_alive(T const& value) const
{
if (is_alive())
{
action(value);
}
}
};
using counter_t = int32_t;
using listeners_t = std::map<counter_t, Event>;
mutable counter_t advise_id = 0;
mutable listeners_t listeners, priority_listeners;
static void cleanup(listeners_t& queue)
{
util::erase_if(queue, [](Event const& e) -> bool { return !e.is_alive(); });
}
void fire_impl(T const& value, listeners_t& queue) const
{
for (auto const& p : queue)
{
auto const& event = p.second;
event.execute_if_alive(value);
}
cleanup(queue);
}
template <typename F>
void advise0(const Lifetime& lifetime, F&& handler, listeners_t& queue) const
{
if (lifetime->is_terminated())
return;
counter_t id = advise_id /*.load()*/;
queue.emplace(id, Event(std::forward<F>(handler), lifetime));
++advise_id;
}
public:
// region ctor/dtor
Signal() = default;
Signal(Signal const& other) = delete;
Signal& operator=(Signal const& other) = delete;
Signal(Signal&&) = default;
Signal& operator=(Signal&&) = default;
virtual ~Signal() = default;
// endregion
using ISignal<T>::fire;
void fire(T const& value) const override
{
fire_impl(value, priority_listeners);
fire_impl(value, listeners);
}
using ISignal<T>::advise;
void advise(Lifetime lifetime, std::function<void(T const&)> handler) const override
{
advise0(lifetime, std::move(handler), isPriorityAdvise() ? priority_listeners : listeners);
}
static bool isPriorityAdvise()
{
return rd_signal_cookie_get() > 0;
}
};
template <typename F>
void priorityAdviseSection(F&& block)
{
rd_signal_cookie_inc();
block();
rd_signal_cookie_dec();
}
} // namespace rd
static_assert(std::is_move_constructible<rd::Signal<int>>::value, "Is not move constructible from Signal<int>");
static_assert(std::is_move_constructible<rd::Signal<rd::Void>>::value, "Is not move constructible from Signal<Void>");
#endif // RD_CPP_CORE_SIGNAL_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/interfaces.h
================================================
#ifndef RD_CPP_CORE_INTERFACES_H
#define RD_CPP_CORE_INTERFACES_H
#include <lifetime/Lifetime.h>
#include <types/wrapper.h>
#include <util/core_traits.h>
#include <functional>
#include <type_traits>
namespace rd
{
/**
* \brief An object that allows to subscribe to events.
* \tparam T type of events
*/
template <typename T>
class ISource
{
public:
virtual ~ISource() = default;
/**
* \brief Adds an event subscription.
* \param lifetime lifetime of subscription.
* \param handler to be called, every time an event occurs.
*/
virtual void advise(Lifetime lifetime, std::function<void(T const&)> handler) const = 0;
/**
* \brief @code advise with Eternal lifetime
*/
template <typename F>
void advise_eternal(F&& handler) const
{
advise(Lifetime::Eternal(), std::forward<F>(handler));
}
/**
* \brief @code Void specialisation of @code advise method, at @tparam T=Void
*/
void advise(Lifetime lifetime, std::function<void()> handler) const
{
advise(lifetime, [handler = std::move(handler)](Void) { handler(); });
}
};
/**
* \brief An object that allows to subscribe to changes of its contents.
* \tparam T type of content
*/
template <typename T>
class IViewable
{
public:
virtual ~IViewable() = default;
virtual void view(Lifetime lifetime, std::function<void(Lifetime, T const&)
>
handler) const = 0;
};
/**
* \brief An object which has a collection of event listeners and can broadcast an event to the listeners.
* \tparam T type of events
*/
template <typename T>
class ISignal : public ISource<T>
{
protected:
using WT = value_or_wrapper<T>;
public:
virtual ~ISignal() = default;
virtual void fire(T const& value) const = 0;
/**
* \brief @code fire specialisation at T=Void
*/
template <typename U = T>
typename std::enable_if_t<util::is_void<U>> fire() const
{
fire(Void{});
}
};
} // namespace rd
#endif // RD_CPP_CORE_INTERFACES_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/viewable_collections.h
================================================
#ifndef RD_CPP_VIEWABLE_COLLECTIONS_H
#define RD_CPP_VIEWABLE_COLLECTIONS_H
#include <string>
namespace rd
{
enum class AddRemove
{
ADD,
REMOVE
};
inline std::string to_string(AddRemove kind)
{
switch (kind)
{
case AddRemove::ADD:
return "Add";
case AddRemove::REMOVE:
return "Remove";
default:
return "";
}
}
enum class Op
{
ADD,
UPDATE,
REMOVE,
ACK
};
inline std::string to_string(Op op)
{
switch (op)
{
case Op::ADD:
return "Add";
case Op::UPDATE:
return "Update";
case Op::REMOVE:
return "Remove";
case Op::ACK:
return "Ack";
default:
return "";
}
}
} // namespace rd
#endif // RD_CPP_VIEWABLE_COLLECTIONS_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/allocator.h
================================================
#ifndef RD_CPP_ALLOCATOR_H
#define RD_CPP_ALLOCATOR_H
#include <memory>
namespace rd
{
template <typename T>
using allocator = std::allocator<T>;
}
#endif // RD_CPP_ALLOCATOR_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/hash.h
================================================
#ifndef RD_CPP_HASH_H
#define RD_CPP_HASH_H
#include <cstddef>
#include <functional>
namespace rd
{
template <typename T>
struct hash
{
size_t operator()(const T& value) const noexcept
{
return std::hash<T>()(value);
}
};
} // namespace rd
#endif // RD_CPP_HASH_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/list.h
================================================
#ifndef RD_CPP_LIST_H
#define RD_CPP_LIST_H
#include <vector>
#include <cstdint>
namespace rd
{
template <typename T>
int32_t size(T const& value) = delete;
// c++17 has std::size for std::vector
#if __cplusplus < 201703L
template <typename T, typename A>
int32_t size(std::vector<T, A> const& value)
{
return static_cast<int32_t>(value.size());
}
#else
template <typename T, typename A>
int32_t size(std::vector<T, A> const& value)
{
return std::size(value);
}
#endif
template <typename T, typename A>
void resize(std::vector<T, A>& value, int32_t size)
{
value.resize(size);
}
} // namespace rd
#endif // RD_CPP_LIST_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/to_string.h
================================================
// ReSharper disable CppUE4CodingStandardNamingViolationWarning
#ifndef RD_CPP_TO_STRING_H
#define RD_CPP_TO_STRING_H
#include <string>
#include <thread>
#include <sstream>
#include <atomic>
#include <future>
#include <locale>
#include "ww898/utf_converters.hpp"
#include <thirdparty.hpp>
namespace rd
{
namespace detail
{
using std::to_string;
inline std::string to_string(std::string const& val)
{
return val;
}
inline std::string to_string(const char* val)
{
return val;
}
inline std::string to_string(std::wstring const& val)
{
return ww898::utf::conv<std::string::value_type>(val);
}
inline std::string to_string(std::thread::id const& id)
{
std::ostringstream ss;
ss << id;
return ss.str();
}
inline std::string to_string(std::exception const& e)
{
return std::string(e.what());
}
inline std::string to_string(std::future_status const& status)
{
switch (status)
{
case std::future_status::ready:
return "ready";
case std::future_status::timeout:
return "timeout";
case std::future_status::deferred:
return "deferred";
default:
return "unknown";
}
}
template <typename Rep, typename Period>
inline std::string to_string(std::chrono::duration<Rep, Period> const& time)
{
return std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(time).count()) + "ms";
}
template <typename T>
inline std::string to_string(T const* val)
{
return val ? to_string(*val) : "nullptr";
}
template <typename T>
inline std::string to_string(std::atomic<T> const& value)
{
return to_string(value.load());
}
template <typename T>
inline std::string to_string(optional<T> const& val)
{
if (val.has_value())
{
return to_string(*val);
}
else
{
return "nullopt";
}
}
template <typename F, typename S>
inline std::string to_string(const std::pair<F, S> p)
{
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <template <class, class> class C, typename T, typename A>
std::string to_string(C<T, A> const& v)
{
std::string res = "[";
for (const auto& item : v)
{
res += to_string(item);
res += ",";
}
res += "]";
return res;
}
template <class T>
std::string as_string(T const& t)
{
return to_string(t);
}
using std::to_wstring;
inline std::wstring to_wstring(std::string const& s)
{
return ww898::utf::conv<std::wstring::value_type>(s);
}
template <class T>
std::wstring as_wstring(T const& t)
{
return to_wstring(t);
}
} // namespace detail
template <typename T>
std::string to_string(T const& val)
{
return detail::as_string(val);
}
template <typename T>
std::wstring to_wstring(T const& val)
{
return detail::as_wstring(val);
}
} // namespace rd
#endif // RD_CPP_TO_STRING_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/unordered_map.h
================================================
#ifndef RD_CPP_UNORDERED_MAP_H
#define RD_CPP_UNORDERED_MAP_H
#include "hash.h"
#include <unordered_map>
namespace rd
{
template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
using unordered_map = std::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>;
}
#endif // RD_CPP_UNORDERED_MAP_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/unordered_set.h
================================================
#ifndef RD_CPP_UNORDERED_SET_H
#define RD_CPP_UNORDERED_SET_H
#include "hash.h"
#include <unordered_set>
namespace rd
{
template <class _Value, class _Hash = hash<_Value>, class _Pred = std::equal_to<_Value>, class _Alloc = std::allocator<_Value> >
using unordered_set = std::unordered_set<_Value, _Hash, _Pred, _Alloc>;
}
#endif // RD_CPP_UNORDERED_SET_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/DateTime.cpp
================================================
#include "DateTime.h"
#include <sstream>
#include <iomanip>
namespace rd
{
DateTime::DateTime(time_t seconds) : seconds(seconds)
{
}
bool operator<(const DateTime& lhs, const DateTime& rhs)
{
return lhs.seconds < rhs.seconds;
}
bool operator>(const DateTime& lhs, const DateTime& rhs)
{
return rhs < lhs;
}
bool operator<=(const DateTime& lhs, const DateTime& rhs)
{
return !(rhs < lhs);
}
bool operator>=(const DateTime& lhs, const DateTime& rhs)
{
return !(lhs < rhs);
}
std::string to_string(DateTime const& time)
{
std::stringstream ss;
ss << std::put_time(std::localtime(&time.seconds), "%F %T");
return ss.str();
}
bool operator==(const DateTime& lhs, const DateTime& rhs)
{
return lhs.seconds == rhs.seconds;
}
bool operator!=(const DateTime& lhs, const DateTime& rhs)
{
return !(rhs == lhs);
}
size_t hash<rd::DateTime>::operator()(const rd::DateTime& value) const noexcept
{
return rd::hash<decltype(value.seconds)>()(value.seconds);
}
} // namespace rd
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/DateTime.h
================================================
#ifndef RD_CPP_DATETIME_H
#define RD_CPP_DATETIME_H
#include <std/hash.h>
#include <ctime>
#include <string>
#include <rd_core_export.h>
namespace rd
{
/**
* \brief Wrapper around time_t to be synchronized with "Date" in Kt and "DateTime" in C#.
*/
class RD_CORE_API DateTime
{
public:
std::time_t seconds;
explicit DateTime(time_t seconds);
friend bool RD_CORE_API operator<(const DateTime& lhs, const DateTime& rhs);
friend bool RD_CORE_API operator>(const DateTime& lhs, const DateTime& rhs);
friend bool RD_CORE_API operator<=(const DateTime& lhs, const DateTime& rhs);
friend bool RD_CORE_API operator>=(const DateTime& lhs, const DateTime& rhs);
friend bool RD_CORE_API operator==(const DateTime& lhs, const DateTime& rhs);
friend bool RD_CORE_API operator!=(const DateTime& lhs, const DateTime& rhs);
//"1970-01-01 03:01:38" for example
friend std::string RD_CORE_API to_string(DateTime const& time);
};
} // namespace rd
namespace rd
{
template <>
struct RD_CORE_API hash<rd::DateTime>
{
size_t operator()(const rd::DateTime& value) const noexcept;
};
} // namespace rd
#endif // RD_CPP_DATETIME_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/Void.h
================================================
#ifndef RD_CPP_VOID_H
#define RD_CPP_VOID_H
#include <functional>
#include <string>
namespace rd
{
/**
* \brief For using in idle events
*/
class Void
{
friend inline bool operator==(const Void&, const Void&)
{
return true;
}
friend inline bool operator!=(const Void&, const Void&)
{
return false;
}
};
inline std::string to_string(Void const&)
{
return "void";
}
} // namespace rd
namespace std
{
template <>
struct hash<rd::Void>
{
size_t operator()(const rd::Void&) const noexcept
{
return 0;
}
};
} // namespace std
#endif // RD_CPP_VOID_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/wrapper.h
================================================
#ifndef RD_CPP_WRAPPER_H
#define RD_CPP_WRAPPER_H
#include <util/core_traits.h>
#include <std/allocator.h>
#include <std/hash.h>
#include <std/to_string.h>
#include <thirdparty.hpp>
#include <type_traits>
#include <memory>
#include <utility>
namespace rd
{
template <typename T, typename A = std::allocator<T>>
class Wrapper;
template <typename T, typename R = void>
struct helper
{
using value_or_wrapper_type = T;
using opt_or_wrapper_type = optional<T>;
using property_storage = optional<T>;
using raw_type = T;
};
template <typename T>
struct helper<T, typename std::enable_if_t<util::in_heap_v<T>>>
{
using value_or_wrapper_type = Wrapper<T>;
using opt_or_wrapper_type = Wrapper<T>;
using property_storage = Wrapper<T>;
using raw_type = T;
};
/*template<typename T>
struct helper<optional<T>> {
using value_or_wrapper_type = Wrapper<T>;
using opt_or_wrapper_type = Wrapper<T>;
using property_storage = optional<optional<T>>;
using raw_type = T;
};*/
template <typename T>
struct helper<Wrapper<T>>
{
using value_or_wrapper_type = Wrapper<T>;
using opt_or_wrapper_type = Wrapper<T>;
using property_storage = Wrapper<Wrapper<T>>;
using raw_type = T;
};
template <typename T>
using value_or_wrapper = typename helper<T>::value_or_wrapper_type;
template <typename T>
using opt_or_wrapper = typename helper<T>::opt_or_wrapper_type;
template <typename T>
using property_storage = typename helper<T>::property_storage;
template <typename T>
using raw_type = typename helper<T>::raw_type;
template <typename>
struct is_wrapper : std::false_type
{
};
template <typename T>
struct is_wrapper<Wrapper<T>> : std::true_type
{
};
template <typename T>
constexpr bool is_wrapper_v = is_wrapper<T>::value;
/**
* \brief wrapper over value of any type. It supports semantic of shared ownership due to shared_ptr as storage.
* \tparam T type of value
*/
template <typename T, typename A>
class Wrapper final : public std::shared_ptr<T>
{
private:
template <typename, typename>
friend class Wrapper;
using Base = std::shared_ptr<T>;
A alloc;
public:
using type = T;
// region ctor/dtor
Wrapper() = default;
Wrapper(Wrapper const&) = default;
Wrapper& operator=(Wrapper const&) = default;
Wrapper(Wrapper&&) = default;
Wrapper& operator=(Wrapper&&) = default;
constexpr explicit Wrapper(std::nullptr_t) noexcept
{
}
constexpr Wrapper(nullopt_t) noexcept
{
}
template <typename R, typename = typename std::enable_if_t<util::is_base_of_v<T, R>>>
Wrapper(Wrapper<R> const& other) : Base(std::static_pointer_cast<T>(static_cast<std::shared_ptr<R>>(other)))
{
}
template <typename R, typename = typename std::enable_if_t<util::is_base_of_v<T, R>>>
Wrapper(Wrapper<R>&& other) : Base(std::static_pointer_cast<T>(static_cast<std::shared_ptr<R>>(std::move(other))))
{
}
template <typename F, typename G = typename util::not_string_literal<F&&>::type,
typename = typename std::enable_if_t<
/*util::negation<
util::disjunction<
std::is_null_pointer<std::decay_t<F>>,
std::is_same<Wrapper<T>, std::decay_t<F>>,
detail::is_optional<std::decay_t<F>>
>
>::value*/
util::conjunction<std::is_constructible<std::shared_ptr<T>, std::shared_ptr<G>>,
util::negation<std::is_abstract<G>>>::value>>
Wrapper(F&& value) : Base(std::allocate_shared<G>(alloc, std::forward<F>(value)))
{
}
template <typename F>
Wrapper(std::shared_ptr<F> const& ptr) noexcept : Base(std::static_pointer_cast<T>(ptr))
{
}
template <typename F>
Wrapper(std::shared_ptr<F>&& ptr) noexcept : Base(std::static_pointer_cast<T>(std::move(ptr)))
{
}
template <typename U = T, typename R = typename std::enable_if_t<!std::is_abstract<std::decay_t<U>>::value>>
Wrapper(optional<U>&& opt)
{
if (opt)
{
*this = std::allocate_shared<U>(alloc, *std::move(opt));
}
}
template <typename R>
static Wrapper<T> dynamic(Wrapper<R> const& w)
{
return Wrapper<T>(std::dynamic_pointer_cast<T>(w));
}
template <typename R>
static Wrapper<T> dynamic(Wrapper<R>&& w)
{
return Wrapper<T>(std::dynamic_pointer_cast<T>(std::move(w)));
}
~Wrapper() = default;
// endregion
constexpr bool has_value() const
{
return operator bool();
}
constexpr T& operator*() &
{
return *static_cast<Base&>(*this);
};
constexpr T const& operator*() const&
{
return *static_cast<Base const&>(*this);
};
/*constexpr T &&operator*() &&{
return *ptr.get();
};*/
T const* operator->() const
{
return Base::operator->();
}
T* operator->()
{
return Base::operator->();
}
explicit operator bool() const noexcept
{
return Base::operator bool();
}
friend bool operator==(const Wrapper& lhs, const Wrapper& rhs)
{
bool is_lhs = (bool) lhs;
bool is_rhs = (bool) rhs;
if (is_lhs != is_rhs)
{
return false;
}
if (!is_lhs && !is_rhs)
{
return true;
}
return *lhs.get() == *rhs.get();
}
friend bool operator!=(const Wrapper& lhs, const Wrapper& rhs)
{
return !(rhs == lhs);
}
friend std::string to_string(Wrapper const& value)
{
return value.has_value() ? to_string(*value) : "nullptr"s;
}
};
namespace wrapper
{
template <typename T>
decltype(auto) get(T&& w)
{
return std::forward<T>(w);
}
template <typename T>
decltype(auto) get(T const& w)
{
return w;
}
template <typename T>
T& get(Wrapper<T>& w)
{
return *w;
}
template <typename T>
T const& get(Wrapper<T> const& w)
{
return *w;
}
template <typename T>
T&& get(Wrapper<T>&& w)
{
return *std::move(std::move(w));
}
/*template<typename T>
Wrapper<T> make_wrapper(std::unique_ptr<T> &&value) {
return Wrapper<T>(std::move(value));
}*/
template <typename T>
typename std::enable_if_t<!util::in_heap_v<T>, T> unwrap(Wrapper<T>&& ptr)
{
return std::move(*ptr);
}
template <typename T>
typename std::enable_if_t<util::in_heap_v<T>, Wrapper<T>> unwrap(Wrapper<T>&& ptr)
{
return Wrapper<T>(std::move(ptr));
}
template <typename T, typename... Args>
Wrapper<T> make_wrapper(Args&&... args)
{
return Wrapper<T>(std::make_shared<T>(std::forward<Args>(args)...));
}
template <typename T, typename A, typename... Args>
Wrapper<T> allocate_wrapper(const A& alloc, Args&&... args)
{
return Wrapper<T>(std::allocate_shared<T, A>(alloc, std::forward<Args>(args)...));
}
/*template<typename T>
constexpr Wrapper<T> null_wrapper = Wrapper<T>(nullptr);*/
} // namespace wrapper
template <typename T>
struct hash<rd::Wrapper<T>>
{
size_t operator()(const rd::Wrapper<T>& value) const noexcept
{
return rd::hash<T>()(*value);
}
};
} // namespace rd
static_assert(rd::is_wrapper<rd::Wrapper<std::wstring>>::value, "is wrapper doesn't work");
#endif // RD_CPP_WRAPPER_H
================================================
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/core_traits.h
================================================
#ifndef RD_CORE_CPP_TRAITS_H
#define RD_CORE_CPP_TRAITS_H
#include <types/Void.h>
#include <type_traits>
#include <string>
namespace rd
{
class IPolymorphicSerializable;
namespace util
{
// region non_std
template <typename T, typename U>
constexpr bool is_same_v = std::is_same<T, U>::value;
template <typename Base, typename Derived>
constexpr bool is_base_of_v = std::is_base_of<Base, Derived>::value;
template <bool B>
using bool_constant = std::integral_constant<bool, B>;
template <class B>
struct negation : bool_constant<!bool(B::value)>
{
};
template <class...>
struct disjunction : std::false_type
{
};
template <class B1>
struct disjunction<B1> : B1
{
};
template <class B1, class... Bn>
struct disjunction<B1, Bn...> : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>>
{
};
template <class...>
struct conjunction : std::true_type
{
};
template <class B1>
struct conjunction<B1> : B1
{
};
template <class B1, class... Bn>
struct conjunction<B1, Bn...> : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1>
{
};
template <class...>
using void_t = void;
template <typename F, typename... Args>
struct is_invocable
: std::is_constructible<std::function<void(Args...)>, std::reference_wrapper<typename std::remove_reference<F>::type>>
{
};
template <typename R, typename F, typename... Args>
struct is_invocable_r
: std::is_constructible<std::function<R(Args...)>, std::reference_wrapper<typename std::remove_reference<F>::type>>
{
};
template <class F, class... Ts>
constexpr bool is_invocable_v = is_invocable<F, Ts...>::value;
#ifdef __cpp_lib_is_invocable
template <class> struct result_of;
template <class F, class... TN>
struct result_of<F(TN...)>
{
using type = std::invoke_result_t<F, TN...>;
};
#else
template<class... TN> using result_of = std::result_of<TN...>;
#endif
template<class... TN> using result_of_t = typename result_of<TN...>::type;
template <typename T>
constexpr bool is_enum_v = std::is_enum<T>::value;
// TO-DO: is is_pod actually required for memcpy-like serialization?
template <class T>
constexpr bool is_pod_v = std::is_trivial<T>::value && std::is_standard_layout<T>::value;
// endregion
template <typename T>
/*inline */ constexpr bool is_void = std::is_same<T, Void>::value;
// region in_heap
template <typename T>
// using in_heap = disjunction<std::is_abstract<T>, std::is_same<T, std::wstring>>;
using in_heap = disjunction<std::is_base_of<IPolymorphicSerializable, T>, std::is_same<T, std::wstring>>;
template <typename T>
/*inline */ constexpr bool in_heap_v = in_heap<T>::value;
static_assert(in_heap_v<std::wstring>, "std::wstring should be placed in shared memory");
static_assert(!in_heap_v<int>, "int shouldn't be placed in shared memory");
// endregion
// region literal
template <typename T>
struct is_wstring_literal :
/*std::is_same<
T,
std::add_lvalue_reference_t<const wchar_t[std::extent<std::remove_reference_t<T>>::value]>*/
std::is_convertible<T, std::wstring>
{
};
template <typename T, bool = is_wstring_literal<T>::value>
struct not_string_literal
{
using type = std::wstring;
};
template <>
struct not_string_literal<std::wstring, true>
{
using type = std::wstring;
};
template <typename T>
struct not_string_literal<T, false>
{
using type = std::decay_t<T>;
};
static_assert(is_wstring_literal<decltype(L" ")>::value, "is_wstring trait doesn't work");
static_assert(is_wstring_literal<decltype(L" ")&&>::value, "is_wstring trait doesn't work");
static_assert(is_wstring_literal<decltype(L" ")&>::value, "is_wstring trait doesn't work");
static_assert(is_wstring_literal<wchar_t const (&)[1]>::value, "is_wstring trait doesn't work");
static_assert(!is_wstring_literal<int>::value, "is_wstring trait doesn't work");
// static_assert(is_wstring_literal<std::wstring>::value, "is_wstring trait doesn't work");
// endregion
} // namespace util
} // namespace rd
#endif // RD_CORE_CPP_TRAITS_H
=======================
gitextract_ql_wvwqe/
├── .editorconfig
├── .gitattributes
├── .github/
│ └── workflows/
│ └── build.yml
├── .gitignore
├── .run/
│ ├── Debug backend.run.xml
│ └── UnrealLink [runIde].run.xml
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── License.txt
├── README.md
├── SETUP.md
├── SdkBasedPluginEmbedding.Root
├── SubplatformsCollection.Root
├── UnrealLink.sln
├── build.gradle.kts
├── gradle/
│ └── wrapper/
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
├── protocol/
│ ├── build.gradle.kts
│ └── src/
│ └── main/
│ └── kotlin/
│ └── model/
│ ├── editorPlugin/
│ │ ├── LiveCodingModel.kt
│ │ └── RdEditorModel.kt
│ ├── lib/
│ │ └── ue4/
│ │ └── UE4Library.kt
│ └── rider/
│ └── RdRiderModel.kt
├── settings.gradle.kts
├── setup_unreal_plugin.cmd
├── src/
│ ├── SubplatformsCollection.Root
│ ├── cpp/
│ │ ├── BuildScript/
│ │ │ └── GenerateRiderLinkZip.cs
│ │ ├── RiderLink/
│ │ │ ├── RiderLink.uplugin.template
│ │ │ └── Source/
│ │ │ ├── RD/
│ │ │ │ ├── RD.Build.cs
│ │ │ │ ├── RD.cpp
│ │ │ │ ├── RD.h
│ │ │ │ ├── src/
│ │ │ │ │ ├── rd_core_cpp/
│ │ │ │ │ │ ├── rd_core_export.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ └── main/
│ │ │ │ │ │ ├── lifetime/
│ │ │ │ │ │ │ ├── Lifetime.cpp
│ │ │ │ │ │ │ ├── Lifetime.h
│ │ │ │ │ │ │ ├── LifetimeDefinition.cpp
│ │ │ │ │ │ │ ├── LifetimeDefinition.h
│ │ │ │ │ │ │ ├── LifetimeImpl.cpp
│ │ │ │ │ │ │ ├── LifetimeImpl.h
│ │ │ │ │ │ │ ├── SequentialLifetimes.cpp
│ │ │ │ │ │ │ └── SequentialLifetimes.h
│ │ │ │ │ │ ├── reactive/
│ │ │ │ │ │ │ ├── Property.h
│ │ │ │ │ │ │ ├── ViewableList.h
│ │ │ │ │ │ │ ├── ViewableMap.h
│ │ │ │ │ │ │ ├── ViewableSet.h
│ │ │ │ │ │ │ └── base/
│ │ │ │ │ │ │ ├── IProperty.h
│ │ │ │ │ │ │ ├── IPropertyBase.h
│ │ │ │ │ │ │ ├── IViewableList.h
│ │ │ │ │ │ │ ├── IViewableMap.h
│ │ │ │ │ │ │ ├── IViewableSet.h
│ │ │ │ │ │ │ ├── SignalCookie.cpp
│ │ │ │ │ │ │ ├── SignalCookie.h
│ │ │ │ │ │ │ ├── SignalX.h
│ │ │ │ │ │ │ ├── interfaces.h
│ │ │ │ │ │ │ └── viewable_collections.h
│ │ │ │ │ │ ├── std/
│ │ │ │ │ │ │ ├── allocator.h
│ │ │ │ │ │ │ ├── hash.h
│ │ │ │ │ │ │ ├── list.h
│ │ │ │ │ │ │ ├── to_string.h
│ │ │ │ │ │ │ ├── unordered_map.h
│ │ │ │ │ │ │ └── unordered_set.h
│ │ │ │ │ │ ├── types/
│ │ │ │ │ │ │ ├── DateTime.cpp
│ │ │ │ │ │ │ ├── DateTime.h
│ │ │ │ │ │ │ ├── Void.h
│ │ │ │ │ │ │ └── wrapper.h
│ │ │ │ │ │ └── util/
│ │ │ │ │ │ ├── core_traits.h
│ │ │ │ │ │ ├── core_util.h
│ │ │ │ │ │ ├── enum.h
│ │ │ │ │ │ ├── erase_if.h
│ │ │ │ │ │ ├── gen_util.h
│ │ │ │ │ │ ├── overloaded.h
│ │ │ │ │ │ └── shared_function.h
│ │ │ │ │ ├── rd_framework_cpp/
│ │ │ │ │ │ ├── rd_framework_export.h
│ │ │ │ │ │ └── src/
│ │ │ │ │ │ └── main/
│ │ │ │ │ │ ├── base/
│ │ │ │ │ │ │ ├── IProtocol.cpp
│ │ │ │ │ │ │ ├── IProtocol.h
│ │ │ │ │ │ │ ├── IRdBindable.h
│ │ │ │ │ │ │ ├── IRdDynamic.h
│ │ │ │ │ │ │ ├── IRdReactive.h
│ │ │ │ │ │ │ ├── IRdWireable.cpp
│ │ │ │ │ │ │ ├── IRdWireable.h
│ │ │ │ │ │ │ ├── ISerializersOwner.cpp
│ │ │ │ │ │ │ ├── ISerializersOwner.h
│ │ │ │ │ │ │ ├── IUnknownInstance.cpp
│ │ │ │ │ │ │ ├── IUnknownInstance.h
│ │ │ │ │ │ │ ├── IWire.h
│ │ │ │ │ │ │ ├── RdBindableBase.cpp
│ │ │ │ │ │ │ ├── RdBindableBase.h
│ │ │ │ │ │ │ ├── RdPropertyBase.h
│ │ │ │ │ │ │ ├── RdReactiveBase.cpp
│ │ │ │ │ │ │ ├── RdReactiveBase.h
│ │ │ │ │ │ │ ├── WireBase.cpp
│ │ │ │ │ │ │ └── WireBase.h
│ │ │ │ │ │ ├── ext/
│ │ │ │ │ │ │ ├── ExtWire.cpp
│ │ │ │ │ │ │ ├── ExtWire.h
│ │ │ │ │ │ │ ├── RdExtBase.cpp
│ │ │ │ │ │ │ └── RdExtBase.h
│ │ │ │ │ │ ├── impl/
│ │ │ │ │ │ │ ├── RName.cpp
│ │ │ │ │ │ │ ├── RName.h
│ │ │ │ │ │ │ ├── RdList.h
│ │ │ │ │ │ │ ├── RdMap.h
│ │ │ │ │ │ │ ├── RdProperty.h
│ │ │ │ │ │ │ ├── RdSet.h
│ │ │ │ │ │ │ └── RdSignal.h
│ │ │ │ │ │ ├── intern/
│ │ │ │ │ │ │ ├── InternRoot.cpp
│ │ │ │ │ │ │ ├── InternRoot.h
│ │ │ │ │ │ │ ├── InternScheduler.cpp
│ │ │ │ │ │ │ └── InternScheduler.h
│ │ │ │ │ │ ├── protocol/
│ │ │ │ │ │ │ ├── Buffer.cpp
│ │ │ │ │ │ │ ├── Buffer.h
│ │ │ │ │ │ │ ├── Identities.cpp
│ │ │ │ │ │ │ ├── Identities.h
│ │ │ │ │ │ │ ├── MessageBroker.cpp
│ │ │ │ │ │ │ ├── MessageBroker.h
│ │ │ │ │ │ │ ├── Protocol.cpp
│ │ │ │ │ │ │ ├── Protocol.h
│ │ │ │ │ │ │ ├── RdId.cpp
│ │ │ │ │ │ │ └── RdId.h
│ │ │ │ │ │ ├── scheduler/
│ │ │ │ │ │ │ ├── SimpleScheduler.cpp
│ │ │ │ │ │ │ ├── SimpleScheduler.h
│ │ │ │ │ │ │ ├── SingleThreadScheduler.cpp
│ │ │ │ │ │ │ ├── SingleThreadScheduler.h
│ │ │ │ │ │ │ ├── SynchronousScheduler.cpp
│ │ │ │ │ │ │ ├── SynchronousScheduler.h
│ │ │ │ │ │ │ └── base/
│ │ │ │ │ │ │ ├── IScheduler.cpp
│ │ │ │ │ │ │ ├── IScheduler.h
│ │ │ │ │ │ │ ├── SingleThreadSchedulerBase.cpp
│ │ │ │ │ │ │ └── SingleThreadSchedulerBase.h
│ │ │ │ │ │ ├── serialization/
│ │ │ │ │ │ │ ├── AbstractPolymorphic.h
│ │ │ │ │ │ │ ├── ArraySerializer.h
│ │ │ │ │ │ │ ├── DefaultAbstractDeclaration.cpp
│ │ │ │ │ │ │ ├── DefaultAbstractDeclaration.h
│ │ │ │ │ │ │ ├── ISerializable.cpp
│ │ │ │ │ │ │ ├── ISerializable.h
│ │ │ │ │ │ │ ├── InternedAnySerializer.h
│ │ │ │ │ │ │ ├── InternedSerializer.h
│ │ │ │ │ │ │ ├── NullableSerializer.h
│ │ │ │ │ │ │ ├── Polymorphic.cpp
│ │ │ │ │ │ │ ├── Polymorphic.h
│ │ │ │ │ │ │ ├── RdAny.cpp
│ │ │ │ │ │ │ ├── RdAny.h
│ │ │ │ │ │ │ ├── SerializationCtx.cpp
│ │ │ │ │ │ │ ├── SerializationCtx.h
│ │ │ │ │ │ │ ├── Serializers.cpp
│ │ │ │ │ │ │ └── Serializers.h
│ │ │ │ │ │ ├── task/
│ │ │ │ │ │ │ ├── RdCall.h
│ │ │ │ │ │ │ ├── RdEndpoint.h
│ │ │ │ │ │ │ ├── RdSymmetricCall.h
│ │ │ │ │ │ │ ├── RdTask.h
│ │ │ │ │ │ │ ├── RdTaskImpl.h
│ │ │ │ │ │ │ ├── RdTaskResult.h
│ │ │ │ │ │ │ ├── WiredRdTask.h
│ │ │ │ │ │ │ └── WiredRdTaskImpl.h
│ │ │ │ │ │ ├── util/
│ │ │ │ │ │ │ ├── framework_traits.h
│ │ │ │ │ │ │ ├── guards.h
│ │ │ │ │ │ │ ├── hashing.cpp
│ │ │ │ │ │ │ ├── hashing.h
│ │ │ │ │ │ │ ├── thread_util.cpp
│ │ │ │ │ │ │ └── thread_util.h
│ │ │ │ │ │ └── wire/
│ │ │ │ │ │ ├── ByteBufferAsyncProcessor.cpp
│ │ │ │ │ │ ├── ByteBufferAsyncProcessor.h
│ │ │ │ │ │ ├── PkgInputStream.cpp
│ │ │ │ │ │ ├── PkgInputStream.h
│ │ │ │ │ │ ├── PumpScheduler.cpp
│ │ │ │ │ │ ├── PumpScheduler.h
│ │ │ │ │ │ ├── SocketWire.cpp
│ │ │ │ │ │ ├── SocketWire.h
│ │ │ │ │ │ ├── WireUtil.cpp
│ │ │ │ │ │ └── WireUtil.h
│ │ │ │ │ └── rd_gen_cpp/
│ │ │ │ │ └── src/
│ │ │ │ │ ├── RdTextBuffer.cpp
│ │ │ │ │ └── RdTextBuffer.h
│ │ │ │ └── thirdparty/
│ │ │ │ ├── CTPL/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── include/
│ │ │ │ │ └── ctpl_stl.h
│ │ │ │ ├── clsocket/
│ │ │ │ │ ├── README
│ │ │ │ │ └── src/
│ │ │ │ │ ├── ActiveSocket.cpp
│ │ │ │ │ ├── ActiveSocket.h
│ │ │ │ │ ├── Host.h
│ │ │ │ │ ├── PassiveSocket.cpp
│ │ │ │ │ ├── PassiveSocket.h
│ │ │ │ │ ├── SimpleSocket.cpp
│ │ │ │ │ ├── SimpleSocket.h
│ │ │ │ │ └── StatTimer.h
│ │ │ │ ├── countdownlatch/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── countdownlatch.cpp
│ │ │ │ │ └── countdownlatch.hpp
│ │ │ │ ├── optional/
│ │ │ │ │ ├── COPYING
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── tl/
│ │ │ │ │ └── optional.hpp
│ │ │ │ ├── ordered-map/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── include/
│ │ │ │ │ └── tsl/
│ │ │ │ │ ├── ordered_hash.h
│ │ │ │ │ ├── ordered_map.h
│ │ │ │ │ └── ordered_set.h
│ │ │ │ ├── spdlog/
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── cmake/
│ │ │ │ │ │ ├── ide.cmake
│ │ │ │ │ │ ├── spdlog.pc.in
│ │ │ │ │ │ ├── spdlogCPack.cmake
│ │ │ │ │ │ ├── spdlogConfig.cmake.in
│ │ │ │ │ │ ├── utils.cmake
│ │ │ │ │ │ └── version.rc.in
│ │ │ │ │ ├── include/
│ │ │ │ │ │ └── spdlog/
│ │ │ │ │ │ ├── async.h
│ │ │ │ │ │ ├── async_logger-inl.h
│ │ │ │ │ │ ├── async_logger.h
│ │ │ │ │ │ ├── cfg/
│ │ │ │ │ │ │ ├── argv.h
│ │ │ │ │ │ │ ├── env.h
│ │ │ │ │ │ │ ├── helpers-inl.h
│ │ │ │ │ │ │ ├── helpers.h
│ │ │ │ │ │ │ └── log_levels.h
│ │ │ │ │ │ ├── common-inl.h
│ │ │ │ │ │ ├── common.h
│ │ │ │ │ │ ├── details/
│ │ │ │ │ │ │ ├── backtracer-inl.h
│ │ │ │ │ │ │ ├── backtracer.h
│ │ │ │ │ │ │ ├── circular_q.h
│ │ │ │ │ │ │ ├── console_globals.h
│ │ │ │ │ │ │ ├── file_helper-inl.h
│ │ │ │ │ │ │ ├── file_helper.h
│ │ │ │ │ │ │ ├── fmt_helper.h
│ │ │ │ │ │ │ ├── log_msg-inl.h
│ │ │ │ │ │ │ ├── log_msg.h
│ │ │ │ │ │ │ ├── log_msg_buffer-inl.h
│ │ │ │ │ │ │ ├── log_msg_buffer.h
│ │ │ │ │ │ │ ├── mpmc_blocking_q.h
│ │ │ │ │ │ │ ├── null_mutex.h
│ │ │ │ │ │ │ ├── os-inl.h
│ │ │ │ │ │ │ ├── os.h
│ │ │ │ │ │ │ ├── periodic_worker-inl.h
│ │ │ │ │ │ │ ├── periodic_worker.h
│ │ │ │ │ │ │ ├── registry-inl.h
│ │ │ │ │ │ │ ├── registry.h
│ │ │ │ │ │ │ ├── synchronous_factory.h
│ │ │ │ │ │ │ ├── tcp_client-windows.h
│ │ │ │ │ │ │ ├── tcp_client.h
│ │ │ │ │ │ │ ├── thread_pool-inl.h
│ │ │ │ │ │ │ ├── thread_pool.h
│ │ │ │ │ │ │ ├── udp_client-windows.h
│ │ │ │ │ │ │ ├── udp_client.h
│ │ │ │ │ │ │ └── windows_include.h
│ │ │ │ │ │ ├── fmt/
│ │ │ │ │ │ │ ├── bin_to_hex.h
│ │ │ │ │ │ │ ├── bundled/
│ │ │ │ │ │ │ │ ├── LICENSE.rst
│ │ │ │ │ │ │ │ ├── args.h
│ │ │ │ │ │ │ │ ├── chrono.h
│ │ │ │ │ │ │ │ ├── color.h
│ │ │ │ │ │ │ │ ├── compile.h
│ │ │ │ │ │ │ │ ├── core.h
│ │ │ │ │ │ │ │ ├── fmt.license.rst
│ │ │ │ │ │ │ │ ├── format-inl.h
│ │ │ │ │ │ │ │ ├── format.h
│ │ │ │ │ │ │ │ ├── locale.h
│ │ │ │ │ │ │ │ ├── os.h
│ │ │ │ │ │ │ │ ├── ostream.h
│ │ │ │ │ │ │ │ ├── posix.h
│ │ │ │ │ │ │ │ ├── printf.h
│ │ │ │ │ │ │ │ ├── ranges.h
│ │ │ │ │ │ │ │ └── xchar.h
│ │ │ │ │ │ │ ├── chrono.h
│ │ │ │ │ │ │ ├── compile.h
│ │ │ │ │ │ │ ├── fmt.h
│ │ │ │ │ │ │ ├── ostr.h
│ │ │ │ │ │ │ ├── ranges.h
│ │ │ │ │ │ │ └── xchar.h
│ │ │ │ │ │ ├── formatter.h
│ │ │ │ │ │ ├── fwd.h
│ │ │ │ │ │ ├── logger-inl.h
│ │ │ │ │ │ ├── logger.h
│ │ │ │ │ │ ├── pattern_formatter-inl.h
│ │ │ │ │ │ ├── pattern_formatter.h
│ │ │ │ │ │ ├── sinks/
│ │ │ │ │ │ │ ├── android_sink.h
│ │ │ │ │ │ │ ├── ansicolor_sink-inl.h
│ │ │ │ │ │ │ ├── ansicolor_sink.h
│ │ │ │ │ │ │ ├── base_sink-inl.h
│ │ │ │ │ │ │ ├── base_sink.h
│ │ │ │ │ │ │ ├── basic_file_sink-inl.h
│ │ │ │ │ │ │ ├── basic_file_sink.h
│ │ │ │ │ │ │ ├── daily_file_sink.h
│ │ │ │ │ │ │ ├── dist_sink.h
│ │ │ │ │ │ │ ├── dup_filter_sink.h
│ │ │ │ │ │ │ ├── hourly_file_sink.h
│ │ │ │ │ │ │ ├── mongo_sink.h
│ │ │ │ │ │ │ ├── msvc_sink.h
│ │ │ │ │ │ │ ├── null_sink.h
│ │ │ │ │ │ │ ├── ostream_sink.h
│ │ │ │ │ │ │ ├── qt_sinks.h
│ │ │ │ │ │ │ ├── ringbuffer_sink.h
│ │ │ │ │ │ │ ├── rotating_file_sink-inl.h
│ │ │ │ │ │ │ ├── rotating_file_sink.h
│ │ │ │ │ │ │ ├── sink-inl.h
│ │ │ │ │ │ │ ├── sink.h
│ │ │ │ │ │ │ ├── stdout_color_sinks-inl.h
│ │ │ │ │ │ │ ├── stdout_color_sinks.h
│ │ │ │ │ │ │ ├── stdout_sinks-inl.h
│ │ │ │ │ │ │ ├── stdout_sinks.h
│ │ │ │ │ │ │ ├── syslog_sink.h
│ │ │ │ │ │ │ ├── systemd_sink.h
│ │ │ │ │ │ │ ├── tcp_sink.h
│ │ │ │ │ │ │ ├── udp_sink.h
│ │ │ │ │ │ │ ├── win_eventlog_sink.h
│ │ │ │ │ │ │ ├── wincolor_sink-inl.h
│ │ │ │ │ │ │ └── wincolor_sink.h
│ │ │ │ │ │ ├── spdlog-inl.h
│ │ │ │ │ │ ├── spdlog.h
│ │ │ │ │ │ ├── stopwatch.h
│ │ │ │ │ │ ├── tweakme.h
│ │ │ │ │ │ └── version.h
│ │ │ │ │ ├── scripts/
│ │ │ │ │ │ ├── extract_version.py
│ │ │ │ │ │ └── format.sh
│ │ │ │ │ └── src/
│ │ │ │ │ ├── async.cpp
│ │ │ │ │ ├── cfg.cpp
│ │ │ │ │ ├── color_sinks.cpp
│ │ │ │ │ ├── file_sinks.cpp
│ │ │ │ │ ├── fmt.cpp
│ │ │ │ │ ├── spdlog.cpp
│ │ │ │ │ └── stdout_sinks.cpp
│ │ │ │ ├── string-view-lite/
│ │ │ │ │ ├── LICENSE.txt
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── cmake/
│ │ │ │ │ │ └── string_view-lite-config.cmake.in
│ │ │ │ │ └── include/
│ │ │ │ │ └── nonstd/
│ │ │ │ │ └── string_view.hpp
│ │ │ │ ├── thirdparty.cpp
│ │ │ │ ├── thirdparty.hpp
│ │ │ │ ├── utf-cpp/
│ │ │ │ │ ├── LICENSE.md
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── include/
│ │ │ │ │ └── ww898/
│ │ │ │ │ ├── cp_utf16.hpp
│ │ │ │ │ ├── cp_utf32.hpp
│ │ │ │ │ ├── cp_utf8.hpp
│ │ │ │ │ ├── cp_utfw.hpp
│ │ │ │ │ ├── utf_config.hpp
│ │ │ │ │ ├── utf_converters.hpp
│ │ │ │ │ ├── utf_selector.hpp
│ │ │ │ │ └── utf_sizes.hpp
│ │ │ │ └── variant/
│ │ │ │ ├── LICENSE.md
│ │ │ │ ├── README.md
│ │ │ │ ├── cmake/
│ │ │ │ │ └── mpark_variant-config.cmake.in
│ │ │ │ └── include/
│ │ │ │ └── mpark/
│ │ │ │ ├── config.hpp
│ │ │ │ ├── in_place.hpp
│ │ │ │ ├── lib.hpp
│ │ │ │ └── variant.hpp
│ │ │ ├── RiderBlueprint/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── BlueprintProvider.cpp
│ │ │ │ │ └── RiderBlueprint.cpp
│ │ │ │ ├── Public/
│ │ │ │ │ ├── BlueprintProvider.hpp
│ │ │ │ │ └── RiderBlueprint.hpp
│ │ │ │ └── RiderBlueprint.Build.cs
│ │ │ ├── RiderDebuggerSupport/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── BlueprintStackGetter.cpp
│ │ │ │ │ ├── DebugLogger.cpp
│ │ │ │ │ ├── DebugLogger.h
│ │ │ │ │ ├── RiderDebuggerSupport.cpp
│ │ │ │ │ ├── RiderDebuggerSupport.h
│ │ │ │ │ ├── UnrealFunctions.cpp
│ │ │ │ │ ├── UnrealFunctions.h
│ │ │ │ │ ├── WideStringWrapper.cpp
│ │ │ │ │ └── WideStringWrapper.h
│ │ │ │ └── RiderDebuggerSupport.Build.cs
│ │ │ ├── RiderGameControl/
│ │ │ │ ├── Private/
│ │ │ │ │ └── RiderGameControl.cpp
│ │ │ │ ├── Public/
│ │ │ │ │ └── RiderGameControl.hpp
│ │ │ │ └── RiderGameControl.Build.cs
│ │ │ ├── RiderLC/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── RiderLC.cpp
│ │ │ │ │ └── RiderLC.hpp
│ │ │ │ └── RiderLC.Build.cs
│ │ │ ├── RiderLink/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── ProtocolFactory.cpp
│ │ │ │ │ ├── ProtocolFactory.h
│ │ │ │ │ ├── RiderLink.cpp
│ │ │ │ │ ├── RiderLink.hpp
│ │ │ │ │ └── UE4TypesMarshallers.cpp
│ │ │ │ ├── Public/
│ │ │ │ │ ├── IRiderLink.hpp
│ │ │ │ │ └── UE4TypesMarshallers.h
│ │ │ │ └── RiderLink.Build.cs
│ │ │ ├── RiderLogging/
│ │ │ │ ├── Private/
│ │ │ │ │ ├── RiderLogging.cpp
│ │ │ │ │ ├── RiderLogging.hpp
│ │ │ │ │ ├── RiderOutputDevice.cpp
│ │ │ │ │ └── RiderOutputDevice.hpp
│ │ │ │ └── RiderLogging.Build.cs
│ │ │ └── RiderShaderInfo/
│ │ │ ├── RiderShaderInfo.Build.cs
│ │ │ ├── RiderShaderInfo.cpp
│ │ │ └── RiderShaderInfo.h
│ │ ├── Subplatform.Root
│ │ └── Subplatform.Snk
│ ├── dotnet/
│ │ ├── BuildScript/
│ │ │ └── DefineUnrealLinkConstants.cs
│ │ ├── Directory.Build.props
│ │ ├── PackagesLock.targets
│ │ ├── Plugin.props
│ │ ├── RiderPlugin.UnrealLink/
│ │ │ ├── BuildScript/
│ │ │ │ └── UnrealLinkInRiderProduct.cs
│ │ │ ├── EditorNavigator.cs
│ │ │ ├── Install/
│ │ │ │ └── AdvertiseRiderBundledPlugin.cs
│ │ │ ├── LinkResolver.cs
│ │ │ ├── PluginInstaller/
│ │ │ │ ├── PluginPathsProvider.cs
│ │ │ │ ├── UnrealPluginDetector.cs
│ │ │ │ ├── UnrealPluginInstallInfo.cs
│ │ │ │ ├── UnrealPluginInstaller.cs
│ │ │ │ └── UnrealProjectsRefresher.cs
│ │ │ ├── Resources/
│ │ │ │ ├── Strings.Designer.cs
│ │ │ │ └── Strings.resx
│ │ │ ├── RiderBackendToUnrealEditor.cs
│ │ │ ├── RiderPlugin.UnrealLink.csproj
│ │ │ ├── Settings/
│ │ │ │ └── UnrealLinkOptionsPage.cs
│ │ │ ├── UnrealEngineAssetsNavigationProvider.cs
│ │ │ ├── UnrealHost.cs
│ │ │ ├── UnrealLiveCodingBuildRunner.cs
│ │ │ ├── Utils/
│ │ │ │ ├── CmdUtils.cs
│ │ │ │ ├── FsUtils.cs
│ │ │ │ └── ModelUtils.cs
│ │ │ └── ZoneMarker.cs
│ │ ├── Subplatform.Root
│ │ ├── Subplatform.Snk
│ │ └── Versions.props
│ └── rider/
│ ├── main/
│ │ ├── kotlin/
│ │ │ ├── com/
│ │ │ │ └── jetbrains/
│ │ │ │ └── rider/
│ │ │ │ ├── UnrealLinkBundle.kt
│ │ │ │ ├── plugins/
│ │ │ │ │ └── unreal/
│ │ │ │ │ ├── RiderLinkInstallService.kt
│ │ │ │ │ ├── UE4LibraryStartUpSerializerRegistrar.kt
│ │ │ │ │ ├── UnrealHost.kt
│ │ │ │ │ ├── UnrealLinkSettings.kt
│ │ │ │ │ ├── UnrealPluginUsagesCollector.kt
│ │ │ │ │ ├── actions/
│ │ │ │ │ │ ├── ActionsUtils.kt
│ │ │ │ │ │ ├── CancelRiderLinkInstallAction.kt
│ │ │ │ │ │ ├── EnableAutoUpdatePlugin.kt
│ │ │ │ │ │ ├── FilterCheckboxAction.kt
│ │ │ │ │ │ ├── HotReloadBuildAction.kt
│ │ │ │ │ │ ├── HotReloadBuildModeProvider.kt
│ │ │ │ │ │ ├── InstallActions.kt
│ │ │ │ │ │ ├── PlayActions.kt
│ │ │ │ │ │ ├── PlaySettingsActions.kt
│ │ │ │ │ │ └── UnrealHostOperations.kt
│ │ │ │ │ ├── debugger/
│ │ │ │ │ │ ├── BlueprintCallstackFrameCompatibilityMatcher.kt
│ │ │ │ │ │ ├── BlueprintCallstackFrameMatchResult.kt
│ │ │ │ │ │ ├── BlueprintExecutionStack.kt
│ │ │ │ │ │ ├── BlueprintStackFrameContainer.kt
│ │ │ │ │ │ ├── BlueprintStackTransformer.kt
│ │ │ │ │ │ ├── UnrealDebugProcessExtension.kt
│ │ │ │ │ │ ├── UnrealDebuggerLogger.kt
│ │ │ │ │ │ ├── actions/
│ │ │ │ │ │ │ ├── FramesPopupGroup.kt
│ │ │ │ │ │ │ ├── ShowBlueprintFunctionsAction.kt
│ │ │ │ │ │ │ ├── ShowLibraryFramesAction.kt
│ │ │ │ │ │ │ ├── ShowUnrealFramesAction.kt
│ │ │ │ │ │ │ └── UnrealToggleBaseAction.kt
│ │ │ │ │ │ └── frames/
│ │ │ │ │ │ ├── BlueprintFrame.kt
│ │ │ │ │ │ ├── BlueprintFrameMessages.kt
│ │ │ │ │ │ ├── StubBlueprintFrame.kt
│ │ │ │ │ │ ├── UnrealExternalCodeFrame.kt
│ │ │ │ │ │ └── UnrealFrameBase.kt
│ │ │ │ │ ├── filters/
│ │ │ │ │ │ └── linkInfo/
│ │ │ │ │ │ ├── BlueprintClassHyperLinkInfo.kt
│ │ │ │ │ │ ├── BlueprintFunctionHyperLinkInfo.kt
│ │ │ │ │ │ ├── MethodReferenceHyperLinkInfo.kt
│ │ │ │ │ │ └── UnrealClassHyperLinkInfo.kt
│ │ │ │ │ ├── notifications/
│ │ │ │ │ │ └── OutOfSyncPluginProtocolListener.kt
│ │ │ │ │ ├── spellchecker/
│ │ │ │ │ │ └── UnrealBundledDictionaryProvider.kt
│ │ │ │ │ └── toolWindow/
│ │ │ │ │ ├── UnrealToolWindowFactory.kt
│ │ │ │ │ └── log/
│ │ │ │ │ ├── UnrealLogCategoryFilterComboBox.kt
│ │ │ │ │ ├── UnrealLogConsoleActionsPostProcessor.kt
│ │ │ │ │ ├── UnrealLogConsoleViewContentType.kt
│ │ │ │ │ ├── UnrealLogFilter.kt
│ │ │ │ │ ├── UnrealLogPanel.kt
│ │ │ │ │ ├── UnrealLogPanelSettings.kt
│ │ │ │ │ ├── UnrealLogSettings.kt
│ │ │ │ │ └── UnrealLogVerbosityFilterComboBox.kt
│ │ │ │ └── settings/
│ │ │ │ ├── UnrealLinkSettingsConfigurable.kt
│ │ │ │ ├── UnrealLogColorSettingsPage.kt
│ │ │ │ └── UnrealLogSettingsConfigurable.kt
│ │ │ └── icons/
│ │ │ └── UnrealIcons.kt
│ │ └── resources/
│ │ ├── META-INF/
│ │ │ └── plugin.xml
│ │ ├── UnrealIconMappings.json
│ │ ├── com/
│ │ │ └── jetbrains/
│ │ │ └── rider/
│ │ │ └── plugins/
│ │ │ └── unreal/
│ │ │ └── spellchecker/
│ │ │ └── unreal.dic
│ │ ├── icon-robots.txt
│ │ ├── icons/
│ │ │ └── expui/
│ │ │ └── icon-robots.txt
│ │ └── messages/
│ │ └── UnrealLinkBundle.properties
│ └── test/
│ ├── kotlin/
│ │ └── com/
│ │ └── jetbrains/
│ │ └── rider/
│ │ └── plugins/
│ │ └── unreal/
│ │ └── test/
│ │ └── cases/
│ │ ├── RiderTestDataMarker.kt
│ │ └── integrationTests/
│ │ ├── Notification.kt
│ │ ├── PlayButtons.kt
│ │ ├── UnrealLinkBase.kt
│ │ ├── UnrealLinkInstallation.kt
│ │ └── projectModel/
│ │ └── RefreshSolution.kt
│ ├── resources/
│ │ ├── episodes/
│ │ │ └── Plugins/
│ │ │ ├── UnrealIntegration.xml
│ │ │ └── UnrealLinkSmoke.xml
│ │ └── intellij.rider.plugins.unreal.link.test.cases.xml
│ └── testData/
│ ├── integrationTests/
│ │ └── projectModel/
│ │ └── RefreshSolution/
│ │ └── refreshSolution/
│ │ ├── refreshSolution.gold
│ │ ├── refreshSolution_4_27.gold
│ │ ├── refreshSolution_5_5.gold
│ │ ├── refreshSolution_text.gold
│ │ ├── refreshSolution_text_4_27.gold
│ │ ├── refreshSolution_text_5_5.gold
│ │ └── refreshSolution_text_5_7.gold
│ ├── solutions/
│ │ └── TestSolutions/
│ │ └── Unreal/
│ │ └── EmptyUProject/
│ │ ├── EmptyUProject.uproject
│ │ └── Source/
│ │ ├── EmptyUProject/
│ │ │ ├── EmptyUProject.Build.cs
│ │ │ ├── EmptyUProject.cpp
│ │ │ └── EmptyUProject.h
│ │ ├── EmptyUProject.Target.cs
│ │ └── EmptyUProjectEditor.Target.cs
│ └── unreal/
│ └── additionalSource/
│ └── plugins/
│ └── EmptyTestPlugin/
│ ├── EmptyTestPlugin.uplugin
│ └── Source/
│ └── EmptyTestPlugin/
│ ├── EmptyTestPlugin.Build.cs
│ ├── Private/
│ │ └── EmptyTestPlugin.cpp
│ └── Public/
│ └── EmptyTestPlugin.h
└── tools/
└── dotnet.cmd
Showing preview only (514K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (1872 symbols across 309 files)
FILE: src/cpp/BuildScript/GenerateRiderLinkZip.cs
class GenerateRiderLinkZip (line 18) | public class GenerateRiderLinkZip
method Run (line 20) | [BuildStep]
FILE: src/cpp/RiderLink/Source/RD/RD.Build.cs
class RD (line 4) | public class RD : ModuleRules
method RD (line 6) | public RD(ReadOnlyTargetRules Target) : base(Target)
FILE: src/cpp/RiderLink/Source/RD/RD.h
function class (line 11) | class FRDModule : public IModuleInterface
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/Lifetime.cpp
type rd (line 9) | namespace rd
function LifetimeImpl (line 13) | LifetimeImpl* Lifetime::operator->() const
function Lifetime (line 27) | Lifetime Lifetime::create_nested() const
function Lifetime (line 34) | Lifetime const& Lifetime::Eternal()
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/Lifetime.h
function namespace (line 17) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeDefinition.cpp
type rd (line 5) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeDefinition.h
function namespace (line 14) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeImpl.cpp
type rd (line 5) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeImpl.h
function LifetimeImpl (line 24) | LifetimeImpl final
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/SequentialLifetimes.cpp
type rd (line 3) | namespace rd
function Lifetime (line 10) | Lifetime SequentialLifetimes::next()
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/SequentialLifetimes.h
function namespace (line 14) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/Property.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableList.h
function namespace (line 12) | namespace rd
function noexcept (line 133) | bool operator<(iterator const& other) const noexcept
function noexcept (line 138) | bool operator>(iterator const& other) const noexcept
function noexcept (line 143) | bool operator==(iterator const& other) const noexcept
function noexcept (line 148) | bool operator!=(iterator const& other) const noexcept
function noexcept (line 153) | bool operator<=(iterator const& other) const noexcept
function noexcept (line 158) | bool operator>=(iterator const& other) const noexcept
function reference (line 163) | reference operator*() noexcept
function reference (line 168) | reference operator*() const noexcept
function pointer (line 173) | pointer operator->() noexcept
function pointer (line 178) | pointer operator->() const noexcept
function advise (line 207) | void advise(Lifetime lifetime, std::function<void(Event const&)> handler...
function add (line 218) | bool add(WT element) const override
function add (line 225) | bool add(size_t index, WT element) const override
function WT (line 232) | WT removeAt(size_t index) const override
function remove (line 241) | bool remove(T const& element) const override
function T (line 252) | T const& get(size_t index) const override
function WT (line 257) | WT set(size_t index, WT element) const override
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableMap.h
function namespace (line 15) | namespace rd
function noexcept (line 133) | bool operator<(iterator const& other) const noexcept
function noexcept (line 138) | bool operator>(iterator const& other) const noexcept
function noexcept (line 143) | bool operator==(iterator const& other) const noexcept
function noexcept (line 148) | bool operator!=(iterator const& other) const noexcept
function noexcept (line 153) | bool operator<=(iterator const& other) const noexcept
function noexcept (line 158) | bool operator>=(iterator const& other) const noexcept
function reference (line 163) | reference operator*() const noexcept
function pointer (line 168) | pointer operator->() const noexcept
function class (line 184) | class reverse_iterator : public std::reverse_iterator<iterator>
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableSet.h
function namespace (line 10) | namespace rd
function noexcept (line 126) | bool operator<(iterator const& other) const noexcept
function noexcept (line 131) | bool operator>(iterator const& other) const noexcept
function noexcept (line 136) | bool operator==(iterator const& other) const noexcept
function noexcept (line 141) | bool operator!=(iterator const& other) const noexcept
function noexcept (line 146) | bool operator<=(iterator const& other) const noexcept
function noexcept (line 151) | bool operator>=(iterator const& other) const noexcept
function reference (line 156) | reference operator*() const noexcept
function pointer (line 161) | pointer operator->() const noexcept
function add (line 191) | bool add(WT element) const override
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IProperty.h
function explicit (line 33) | explicit IProperty(T const& value) : IPropertyBase<T>(value)
function advise_before (line 61) | void advise_before(Lifetime lifetime, std::function<void(T const&)> hand...
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IPropertyBase.h
function namespace (line 12) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableList.h
function class (line 38) | class Update
function advise_add_remove (line 142) | void advise_add_remove(Lifetime lifetime, std::function<void(AddRemove, ...
function view (line 160) | void view(Lifetime lifetime, std::function<void(Lifetime lifetime, std::...
function view (line 168) | void view(Lifetime lifetime, std::function<void(Lifetime, size_t, T cons...
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableMap.h
function v (line 58) | MapEvent(Add x) : v(x)
function v (line 62) | MapEvent(Update x) : v(x)
function v (line 66) | MapEvent(Remove x) : v(x)
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableSet.h
function namespace (line 16) | namespace detail
function advise (line 73) | void advise(Lifetime lifetime, std::function<void(AddRemove, T const&)> ...
function view (line 88) | void view(Lifetime lifetime, std::function<void(Lifetime, T const&)> han...
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/SignalCookie.cpp
function rd_signal_cookie_inc (line 10) | void rd_signal_cookie_inc()
function rd_signal_cookie_dec (line 15) | void rd_signal_cookie_dec()
function rd_signal_cookie_get (line 20) | int32_t rd_signal_cookie_get()
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/SignalX.h
function class (line 25) | class Event
function cleanup (line 63) | static void cleanup(listeners_t& queue)
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/interfaces.h
function namespace (line 11) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/viewable_collections.h
type class (line 8) | enum class
function std (line 14) | inline std::string to_string(AddRemove kind)
function Op (line 27) | enum class Op
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/allocator.h
function namespace (line 6) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/hash.h
function namespace (line 7) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/list.h
function namespace (line 7) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/to_string.h
function namespace (line 16) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/unordered_map.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/unordered_set.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/DateTime.cpp
type rd (line 6) | namespace rd
function to_string (line 32) | std::string to_string(DateTime const& time)
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/DateTime.h
function namespace (line 11) | namespace rd
function namespace (line 39) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/Void.h
function Void (line 34) | struct hash<rd::Void>
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/wrapper.h
function namespace (line 15) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/core_traits.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/core_util.h
function namespace (line 39) | namespace util
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/erase_if.h
function namespace (line 4) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/gen_util.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/overloaded.h
function namespace (line 4) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/shared_function.h
function namespace (line 6) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IProtocol.cpp
type rd (line 11) | namespace rd
function IProtocol (line 22) | const IProtocol* IProtocol::get_protocol() const
function IScheduler (line 27) | IScheduler* IProtocol::get_scheduler() const
function IWire (line 32) | const IWire* IProtocol::get_wire() const
function Serializers (line 37) | const Serializers& IProtocol::get_serializers() const
function Identities (line 42) | const Identities* IProtocol::get_identity() const
function RName (line 47) | const RName& IProtocol::get_location() const
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IProtocol.h
function namespace (line 19) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdBindable.h
function namespace (line 10) | namespace rd
function namespace (line 15) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdDynamic.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdReactive.h
function namespace (line 10) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdWireable.cpp
type rd (line 3) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdWireable.h
function namespace (line 10) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/ISerializersOwner.cpp
type rd (line 3) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/ISerializersOwner.h
function namespace (line 13) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IUnknownInstance.cpp
type rd (line 3) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IUnknownInstance.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdBindableBase.cpp
type rd (line 5) | namespace rd
function IProtocol (line 51) | const IProtocol* RdBindableBase::get_protocol() const
function RName (line 64) | const RName& RdBindableBase::get_location() const
function RdId (line 69) | RdId RdBindableBase::get_id() const
function SerializationCtx (line 79) | SerializationCtx& RdBindableBase::get_serialization_context() const
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdBindableBase.h
function namespace (line 16) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdPropertyBase.h
function namespace (line 13) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdReactiveBase.cpp
type rd (line 5) | namespace rd
function RdReactiveBase (line 17) | RdReactiveBase& RdReactiveBase::operator=(RdReactiveBase&& other)
function IWire (line 24) | const IWire* RdReactiveBase::get_wire() const
function Serializers (line 45) | const Serializers& RdReactiveBase::get_serializers() const
function IScheduler (line 50) | IScheduler* RdReactiveBase::get_default_scheduler() const
function IScheduler (line 55) | IScheduler* RdReactiveBase::get_wire_scheduler() const
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdReactiveBase.h
function namespace (line 17) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/WireBase.cpp
type rd (line 3) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/WireBase.h
function namespace (line 10) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/ext/ExtWire.cpp
type rd (line 5) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/ext/ExtWire.h
function namespace (line 19) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/ext/RdExtBase.cpp
type rd (line 8) | namespace rd
function IProtocol (line 10) | const IProtocol* RdExtBase::get_protocol() const
function IScheduler (line 96) | IScheduler* RdExtBase::get_wire_scheduler() const
function to_string (line 101) | std::string to_string(RdExtBase::ExtState state)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/ext/RdExtBase.h
type class (line 28) | enum class
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RName.cpp
type rd (line 5) | namespace rd
class RNameImpl (line 7) | class RNameImpl
method RNameImpl (line 13) | RNameImpl(const RName& other) = delete;
method RNameImpl (line 14) | RNameImpl(RName&& other) noexcept = delete;
method RNameImpl (line 15) | RNameImpl& operator=(const RNameImpl& other) = delete;
method RNameImpl (line 16) | RNameImpl& operator=(RNameImpl&& other) noexcept = delete;
function RName (line 36) | RName RName::sub(string_view localName, string_view separator) const
function to_string (line 41) | std::string to_string(RName const& value)
function to_string (line 51) | std::string to_string(RNameImpl const& value)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RName.h
function namespace (line 14) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdList.h
function namespace (line 14) | namespace rd
function WT (line 191) | WT removeAt(size_t index) const override
function T (line 196) | T const& get(size_t index) const override
function WT (line 201) | WT set(size_t index, WT element) const override
function size (line 211) | size_t size() const override
function override (line 221) | const override
function addAll (line 226) | bool addAll(size_t index, std::vector<WT> elements) const override
function addAll (line 231) | bool addAll(std::vector<WT> elements) const override
function removeAll (line 236) | bool removeAll(std::vector<WT> elements) const override
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdMap.h
function namespace (line 16) | namespace rd
function write (line 82) | void write(SerializationCtx& /*ctx*/, Buffer& buffer) const override
function init (line 89) | void init(Lifetime lifetime) const override
function on_wire_received (line 141) | void on_wire_received(Buffer buffer) const override
function advise (line 244) | void advise(Lifetime lifetime, std::function<void(Event const&)> handler...
function V (line 253) | V const* get(K const& key) const override
function V (line 258) | V const* set(WK key, WV value) const override
function OV (line 263) | OV remove(K const& key) const override
function empty (line 278) | bool empty() const override
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdProperty.h
function namespace (line 14) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdSet.h
function write (line 56) | void write(SerializationCtx& /*ctx*/, Buffer& buffer) const override
function init (line 63) | void init(Lifetime lifetime) const override
function on_wire_received (line 84) | void on_wire_received(Buffer buffer) const override
function add (line 104) | bool add(WT value) const override
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdSignal.h
function namespace (line 16) | namespace rd
function init (line 75) | void init(Lifetime lifetime) const override
function on_wire_received (line 82) | void on_wire_received(Buffer buffer) const override
function fire (line 92) | void fire(T const& value) const override
function advise (line 114) | void advise(Lifetime lifetime, std::function<void(T const&)> handler) co...
function IScheduler (line 134) | IScheduler* get_wire_scheduler() const override
function friend (line 139) | friend std::string to_string(RdSignal const&)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/intern/InternRoot.cpp
type rd (line 6) | namespace rd
function IScheduler (line 13) | IScheduler* InternRoot::get_wire_scheduler() const
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/intern/InternRoot.h
function namespace (line 25) | namespace rd
function namespace (line 79) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/intern/InternScheduler.cpp
type rd (line 5) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/intern/InternScheduler.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Buffer.cpp
type rd (line 8) | namespace rd
function read_wstring_spec (line 135) | std::wstring read_wstring_spec(Buffer& buffer)
function write_wstring_spec (line 158) | void write_wstring_spec(Buffer& buffer, wstring_view value)
function DateTime (line 205) | DateTime Buffer::read_date_time()
function wchar_t (line 230) | wchar_t Buffer::read_char()
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Buffer.h
function namespace (line 22) | namespace rd
function write_array (line 146) | void write_array(C<T, A> const& container)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Identities.cpp
type rd (line 3) | namespace rd
function RdId (line 12) | RdId Identities::next(const RdId& parent) const
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Identities.h
function class (line 20) | class RD_FRAMEWORK_API Identities
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/MessageBroker.cpp
type rd (line 6) | namespace rd
function execute (line 11) | static void execute(const IRdReactive* that, Buffer msg)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/MessageBroker.h
function namespace (line 19) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Protocol.cpp
type rd (line 10) | namespace rd
function SerializationCtx (line 42) | SerializationCtx& Protocol::get_serialization_context() const
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Protocol.h
function string_view (line 31) | constexpr static string_view InternRootName{"ProtocolInternRoot"};
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/RdId.cpp
type rd (line 5) | namespace rd
function RdId (line 7) | RdId RdId::read(Buffer& buffer)
function to_string (line 18) | std::string to_string(RdId const& id)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/RdId.h
function hash (line 21) | struct RD_FRAMEWORK_API hash<RdId>
function hash_t (line 39) | hash_t hash{NULL_ID};
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SimpleScheduler.cpp
type rd (line 3) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SimpleScheduler.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SingleThreadScheduler.cpp
type rd (line 7) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SingleThreadScheduler.h
function namespace (line 10) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SynchronousScheduler.cpp
type rd (line 5) | namespace rd
function SynchronousScheduler (line 24) | SynchronousScheduler& SynchronousScheduler::Instance()
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SynchronousScheduler.h
function namespace (line 10) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/base/IScheduler.cpp
type rd (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/base/IScheduler.h
function namespace (line 14) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/base/SingleThreadSchedulerBase.cpp
type rd (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/base/SingleThreadSchedulerBase.h
function namespace (line 17) | namespace ctpl
function namespace (line 22) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/AbstractPolymorphic.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/ArraySerializer.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/DefaultAbstractDeclaration.cpp
type rd (line 3) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/DefaultAbstractDeclaration.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/ISerializable.cpp
type rd (line 5) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/ISerializable.h
function class (line 21) | class RD_FRAMEWORK_API ISerializable
function virtual (line 43) | virtual size_t hashCode() const noexcept;
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/InternedAnySerializer.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/InternedSerializer.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/NullableSerializer.h
function namespace (line 11) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/Polymorphic.cpp
type rd (line 3) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/Polymorphic.h
function namespace (line 9) | namespace rd
function write (line 51) | inline static void write(SerializationCtx& /*ctx*/, Buffer& buffer, T co...
function write (line 66) | inline static void write(SerializationCtx& /*ctx*/, Buffer& buffer, T co...
function write (line 99) | inline static void write(SerializationCtx& /*ctx*/, Buffer& buffer, bool...
function write (line 114) | inline static void write(SerializationCtx& /*ctx*/, Buffer& buffer, bool...
function write (line 149) | inline static void write(SerializationCtx& /*ctx*/, Buffer& buffer, Date...
function write (line 164) | inline static void write(SerializationCtx& /*ctx*/, Buffer& /*buffer*/, ...
function write (line 193) | inline static void write(SerializationCtx& /*ctx*/, Buffer& buffer, T co...
function write (line 208) | inline static void write(SerializationCtx& ctx, Buffer& buffer, optional...
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/RdAny.cpp
type rd (line 3) | namespace rd
type any (line 5) | namespace any
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/RdAny.h
function namespace (line 14) | namespace rd
function value (line 100) | struct TransparentHash
function const (line 112) | size_t operator()(wrapped_super_t const& value) const noexcept
function const (line 117) | size_t operator()(super_t const& value) const noexcept
function const (line 122) | size_t operator()(any::string const& value) const noexcept
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/SerializationCtx.cpp
type rd (line 3) | namespace rd
function SerializationCtx (line 14) | SerializationCtx SerializationCtx::withInternRootsHere(
function Serializers (line 28) | Serializers const& SerializationCtx::get_serializers() const
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/SerializationCtx.h
function namespace (line 21) | namespace rd
function namespace (line 76) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/Serializers.cpp
type rd (line 5) | namespace rd
function RdId (line 9) | RdId Serializers::real_rd_id(const IUnknownInstance& value)
function RdId (line 14) | RdId Serializers::real_rd_id(const IPolymorphicSerializable& value)
function RdId (line 19) | RdId Serializers::real_rd_id(const std::wstring& /*value*/)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/Serializers.h
function namespace (line 25) | namespace rd
function namespace (line 77) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdCall.h
function namespace (line 17) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdEndpoint.h
function namespace (line 12) | namespace rd
function init (line 86) | void init(Lifetime lifetime) const override
function on_wire_received (line 93) | void on_wire_received(Buffer buffer) const override
function friend (line 132) | friend std::string to_string(RdEndpoint const& /*value*/)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdSymmetricCall.h
function namespace (line 7) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdTask.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdTaskImpl.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdTaskResult.h
function namespace (line 14) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/WiredRdTask.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/WiredRdTaskImpl.h
function namespace (line 7) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/framework_traits.h
function namespace (line 9) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/guards.h
function namespace (line 4) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/hashing.h
function namespace (line 10) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/thread_util.cpp
type tagTHREADNAME_INFO (line 9) | struct tagTHREADNAME_INFO
function SetThreadName (line 18) | void SetThreadName(uint32_t dwThreadID, const char* threadName)
function SetThreadName (line 35) | void SetThreadName(const char* threadName)
function SetThreadName (line 44) | void SetThreadName(const char* threadName)
function SetThreadName (line 53) | void SetThreadName(const char* threadName)
type rd (line 60) | namespace rd
type util (line 62) | namespace util
function set_thread_name (line 64) | void set_thread_name(const char* name)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/thread_util.h
function namespace (line 6) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/ByteBufferAsyncProcessor.cpp
type rd (line 8) | namespace rd
function to_string (line 274) | std::string to_string(ByteBufferAsyncProcessor::StateKind state)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/ByteBufferAsyncProcessor.h
type class (line 28) | enum class
function StateKind (line 49) | StateKind state{StateKind::Initialized};
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/PkgInputStream.cpp
type rd (line 7) | namespace rd
function Buffer (line 29) | Buffer& PkgInputStream::get_buffer()
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/PkgInputStream.h
function namespace (line 13) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/PumpScheduler.cpp
type rd (line 5) | namespace rd
type test (line 7) | namespace test
type util (line 9) | namespace util
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/PumpScheduler.h
function namespace (line 17) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/SocketWire.cpp
type rd (line 15) | namespace rd
function CSimpleSocket (line 369) | CSimpleSocket* SocketWire::Base::get_socket_provider() const
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/SocketWire.h
function class (line 26) | class RD_FRAMEWORK_API SocketWire
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/WireUtil.cpp
type rd (line 11) | namespace rd
type util (line 13) | namespace util
function find_free_port (line 15) | uint16_t find_free_port()
function sleep_this_thread (line 25) | void sleep_this_thread(int64_t ms)
FILE: src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/WireUtil.h
function namespace (line 8) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/src/rd_gen_cpp/src/RdTextBuffer.h
function namespace (line 4) | namespace rd
FILE: src/cpp/RiderLink/Source/RD/thirdparty/CTPL/include/ctpl_stl.h
function namespace (line 41) | namespace ctpl {
function pck (line 174) | auto pck = std::make_shared<std::packaged_task<decltype(f(0, rest...))(i...
function set_thread (line 209) | void set_thread(int i) {
function init (line 236) | void init() { this->nWaiting = 0; this->isStop = false; this->isDone = f...
FILE: src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/ActiveSocket.cpp
type in_addr (line 57) | struct in_addr
type sockaddr (line 96) | struct sockaddr
type in_addr (line 137) | struct in_addr
type sockaddr (line 176) | struct sockaddr
type in_addr (line 196) | struct in_addr
type sockaddr (line 234) | struct sockaddr
type sockaddr (line 297) | struct sockaddr
type sockaddr (line 300) | struct sockaddr
type sockaddr (line 302) | struct sockaddr
type sockaddr (line 304) | struct sockaddr
FILE: src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/ActiveSocket.h
function class (line 54) | class CActiveSocket : public CSimpleSocket {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/Host.h
type SOCKET (line 66) | typedef int SOCKET;
type iovec (line 70) | struct iovec {
type socklen_t (line 77) | typedef int socklen_t;
FILE: src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/PassiveSocket.cpp
type sockaddr (line 81) | struct sockaddr
type sockaddr (line 161) | struct sockaddr
type sockaddr (line 164) | struct sockaddr
function CActiveSocket (line 200) | CActiveSocket *CPassiveSocket::Accept() {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/PassiveSocket.h
function class (line 55) | class CPassiveSocket : public CSimpleSocket {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/SimpleSocket.cpp
type timeval (line 54) | struct timeval
type timeval (line 55) | struct timeval
type linger (line 56) | struct linger
function CSimpleSocket (line 117) | CSimpleSocket *CSimpleSocket::operator=(CSimpleSocket &socket)
type in_addr (line 170) | struct in_addr
type iovec (line 558) | struct iovec
type iovec (line 592) | struct iovec
type timeval (line 615) | struct timeval
type timeval (line 624) | struct timeval
type timeval (line 643) | struct timeval
type timeval (line 651) | struct timeval
type sockaddr_in (line 777) | struct sockaddr_in
type timeval (line 1129) | struct timeval
type timeval (line 1130) | struct timeval
FILE: src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/SimpleSocket.h
function class (line 105) | class CSimpleSocket {
function GetReceiveTimeoutSec (line 356) | int32_t GetReceiveTimeoutSec(void) {
function GetReceiveTimeoutUSec (line 363) | int32_t GetReceiveTimeoutUSec(void) {
function GetMulticast (line 388) | bool GetMulticast() {
function GetSendTimeoutSec (line 399) | int32_t GetSendTimeoutSec(void) {
function GetSendTimeoutUSec (line 406) | int32_t GetSendTimeoutUSec(void) {
function CSocketError (line 419) | CSocketError GetSocketError(void) {
function GetTotalTimeMs (line 425) | uint32_t GetTotalTimeMs() {
function GetTotalTimeUsec (line 431) | uint32_t GetTotalTimeUsec() {
function SOCKET (line 448) | SOCKET GetSocketDescriptor() {
function CSocketType (line 454) | CSocketType GetSocketType() {
function GetClientPort (line 466) | uint16_t GetClientPort() {
function GetServerPort (line 478) | uint16_t GetServerPort() {
function GetReceiveWindowSize (line 485) | uint32_t GetReceiveWindowSize() {
function GetSendWindowSize (line 492) | uint32_t GetSendWindowSize() {
function SetReceiveWindowSize (line 499) | uint32_t SetReceiveWindowSize(uint32_t nWindowSize) {
function SetSendWindowSize (line 506) | uint32_t SetSendWindowSize(uint32_t nWindowSize) {
function SetSocketHandle (line 532) | void SetSocketHandle(SOCKET socket) {
type iovec (line 555) | struct iovec
type timeval (line 571) | struct timeval
type timeval (line 572) | struct timeval
type timeval (line 573) | struct timeval
type sockaddr_in (line 574) | struct sockaddr_in
type sockaddr_in (line 575) | struct sockaddr_in
type sockaddr_in (line 576) | struct sockaddr_in
type linger (line 577) | struct linger
FILE: src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/StatTimer.h
function class (line 76) | class CStatTimer {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/countdownlatch/countdownlatch.hpp
type clatch (line 10) | namespace clatch
class countdownlatch (line 12) | class countdownlatch {
method countdownlatch (line 45) | countdownlatch() = delete;
method countdownlatch (line 46) | countdownlatch(const countdownlatch& other) = delete;
method countdownlatch (line 47) | countdownlatch& operator=(const countdownlatch& opther) = delete;
FILE: src/cpp/RiderLink/Source/RD/thirdparty/optional/tl/optional.hpp
type tl (line 65) | namespace tl {
type detail (line 66) | namespace detail {
type is_trivially_copy_constructible (line 68) | struct is_trivially_copy_constructible : std::is_trivially_copy_cons...
type is_trivially_copy_constructible<std::vector<T,A>> (line 71) | struct is_trivially_copy_constructible<std::vector<T,A>>
type conjunction (line 136) | struct conjunction : std::true_type {}
type conjunction<B> (line 137) | struct conjunction<B> : B {}
type is_pointer_to_non_const_member_func (line 150) | struct is_pointer_to_non_const_member_func : std::false_type{}
type is_const_or_const_ref (line 164) | struct is_const_or_const_ref : std::false_type{}
type is_const_or_const_ref<T const&> (line 165) | struct is_const_or_const_ref<T const&> : std::true_type{}
type is_const_or_const_ref<T const> (line 166) | struct is_const_or_const_ref<T const> : std::true_type{}
function invoke (line 178) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 186) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 193) | struct invoke_result_impl
type voider (line 210) | struct voider { using type = void; }
type is_optional_impl (line 214) | struct is_optional_impl : std::false_type {}
type is_optional_impl<optional<T>> (line 215) | struct is_optional_impl<optional<T>> : std::true_type {}
type returns_void_impl (line 226) | struct returns_void_impl
type is_swappable (line 283) | struct is_swappable : std::true_type {}
type is_nothrow_swappable (line 285) | struct is_nothrow_swappable : std::true_type {}
type swap_adl_tests (line 288) | namespace swap_adl_tests {
type tag (line 291) | struct tag {}
type is_std_swap_noexcept (line 310) | struct is_std_swap_noexcept
type is_std_swap_noexcept<T[N]> (line 316) | struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}
type is_adl_swap_noexcept (line 319) | struct is_adl_swap_noexcept
type is_swappable (line 324) | struct is_swappable
type is_swappable<T[N], T[N]> (line 333) | struct is_swappable<T[N], T[N]>
type is_nothrow_swappable (line 342) | struct is_nothrow_swappable
type optional_storage_base (line 358) | struct optional_storage_base {
method TL_OPTIONAL_11_CONSTEXPR (line 363) | TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
type dummy (line 373) | struct dummy {}
type optional_storage_base<T, true> (line 383) | struct optional_storage_base<T, true> {
type dummy (line 393) | struct dummy {}
type optional_operations_base (line 404) | struct optional_operations_base : optional_storage_base<T> {
method hard_reset (line 407) | void hard_reset() noexcept {
method construct (line 412) | void construct(Args &&... args) noexcept {
method assign (line 417) | void assign(Opt &&rhs) {
method has_value (line 432) | bool has_value() const { return this->m_has_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 434) | TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 435) | TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_v...
method TL_OPTIONAL_11_CONSTEXPR (line 436) | TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_v...
method T (line 438) | constexpr const T &&get() const && { return std::move(this->m_valu...
type optional_copy_base (line 445) | struct optional_copy_base : optional_operations_base<T> {
type optional_copy_base<T, false> (line 451) | struct optional_copy_base<T, false> : optional_operations_base<T> {
method optional_copy_base (line 454) | optional_copy_base() = default;
method optional_copy_base (line 455) | optional_copy_base(const optional_copy_base &rhs) {
method optional_copy_base (line 463) | optional_copy_base(optional_copy_base &&rhs) = default;
method optional_copy_base (line 464) | optional_copy_base &operator=(const optional_copy_base &rhs) = def...
method optional_copy_base (line 465) | optional_copy_base &operator=(optional_copy_base &&rhs) = default;
type optional_move_base (line 475) | struct optional_move_base : optional_copy_base<T> {
type optional_move_base (line 479) | struct optional_move_base
type optional_move_base<T, false> (line 481) | struct optional_move_base<T, false> : optional_copy_base<T> {
method optional_move_base (line 484) | optional_move_base() = default;
method optional_move_base (line 485) | optional_move_base(const optional_move_base &rhs) = default;
method optional_move_base (line 487) | optional_move_base(optional_move_base &&rhs) noexcept(
method optional_move_base (line 495) | optional_move_base &operator=(const optional_move_base &rhs) = def...
method optional_move_base (line 496) | optional_move_base &operator=(optional_move_base &&rhs) = default;
type optional_copy_assign_base (line 503) | struct optional_copy_assign_base : optional_move_base<T> {
type optional_copy_assign_base<T, false> (line 508) | struct optional_copy_assign_base<T, false> : optional_move_base<T> {
method optional_copy_assign_base (line 511) | optional_copy_assign_base() = default;
method optional_copy_assign_base (line 512) | optional_copy_assign_base(const optional_copy_assign_base &rhs) = ...
method optional_copy_assign_base (line 514) | optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
method optional_copy_assign_base (line 515) | optional_copy_assign_base &operator=(const optional_copy_assign_ba...
method optional_copy_assign_base (line 519) | optional_copy_assign_base &
type optional_move_assign_base (line 532) | struct optional_move_assign_base : optional_copy_assign_base<T> {
type optional_move_assign_base (line 536) | struct optional_move_assign_base
type optional_move_assign_base<T, false> (line 540) | struct optional_move_assign_base<T, false> : optional_copy_assign_ba...
method optional_move_assign_base (line 543) | optional_move_assign_base() = default;
method optional_move_assign_base (line 544) | optional_move_assign_base(const optional_move_assign_base &rhs) = ...
method optional_move_assign_base (line 546) | optional_move_assign_base(optional_move_assign_base &&rhs) = default;
method optional_move_assign_base (line 548) | optional_move_assign_base &
method optional_move_assign_base (line 551) | optional_move_assign_base &
type optional_delete_ctor_base (line 564) | struct optional_delete_ctor_base {
method optional_delete_ctor_base (line 565) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 566) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 567) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 568) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 570) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, true, false> (line 574) | struct optional_delete_ctor_base<T, true, false> {
method optional_delete_ctor_base (line 575) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 576) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 577) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 578) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 580) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, true> (line 584) | struct optional_delete_ctor_base<T, false, true> {
method optional_delete_ctor_base (line 585) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 586) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 587) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 588) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 590) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, false> (line 594) | struct optional_delete_ctor_base<T, false, false> {
method optional_delete_ctor_base (line 595) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 596) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 597) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 598) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 600) | optional_delete_ctor_base &
type optional_delete_assign_base (line 611) | struct optional_delete_assign_base {
method optional_delete_assign_base (line 612) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 613) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 614) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 616) | optional_delete_assign_base &
method optional_delete_assign_base (line 618) | optional_delete_assign_base &
type optional_delete_assign_base<T, true, false> (line 622) | struct optional_delete_assign_base<T, true, false> {
method optional_delete_assign_base (line 623) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 624) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 625) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 627) | optional_delete_assign_base &
method optional_delete_assign_base (line 629) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, true> (line 633) | struct optional_delete_assign_base<T, false, true> {
method optional_delete_assign_base (line 634) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 635) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 636) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 638) | optional_delete_assign_base &
method optional_delete_assign_base (line 640) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, false> (line 644) | struct optional_delete_assign_base<T, false, false> {
method optional_delete_assign_base (line 645) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 646) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 647) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 649) | optional_delete_assign_base &
method optional_delete_assign_base (line 651) | optional_delete_assign_base &
class monostate (line 109) | class monostate {}
type in_place_t (line 112) | struct in_place_t {
method in_place_t (line 113) | explicit in_place_t() = default;
class optional (line 119) | class optional
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
type detail (line 122) | namespace detail {
type is_trivially_copy_constructible (line 68) | struct is_trivially_copy_constructible : std::is_trivially_copy_cons...
type is_trivially_copy_constructible<std::vector<T,A>> (line 71) | struct is_trivially_copy_constructible<std::vector<T,A>>
type conjunction (line 136) | struct conjunction : std::true_type {}
type conjunction<B> (line 137) | struct conjunction<B> : B {}
type is_pointer_to_non_const_member_func (line 150) | struct is_pointer_to_non_const_member_func : std::false_type{}
type is_const_or_const_ref (line 164) | struct is_const_or_const_ref : std::false_type{}
type is_const_or_const_ref<T const&> (line 165) | struct is_const_or_const_ref<T const&> : std::true_type{}
type is_const_or_const_ref<T const> (line 166) | struct is_const_or_const_ref<T const> : std::true_type{}
function invoke (line 178) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 186) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 193) | struct invoke_result_impl
type voider (line 210) | struct voider { using type = void; }
type is_optional_impl (line 214) | struct is_optional_impl : std::false_type {}
type is_optional_impl<optional<T>> (line 215) | struct is_optional_impl<optional<T>> : std::true_type {}
type returns_void_impl (line 226) | struct returns_void_impl
type is_swappable (line 283) | struct is_swappable : std::true_type {}
type is_nothrow_swappable (line 285) | struct is_nothrow_swappable : std::true_type {}
type swap_adl_tests (line 288) | namespace swap_adl_tests {
type tag (line 291) | struct tag {}
type is_std_swap_noexcept (line 310) | struct is_std_swap_noexcept
type is_std_swap_noexcept<T[N]> (line 316) | struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}
type is_adl_swap_noexcept (line 319) | struct is_adl_swap_noexcept
type is_swappable (line 324) | struct is_swappable
type is_swappable<T[N], T[N]> (line 333) | struct is_swappable<T[N], T[N]>
type is_nothrow_swappable (line 342) | struct is_nothrow_swappable
type optional_storage_base (line 358) | struct optional_storage_base {
method TL_OPTIONAL_11_CONSTEXPR (line 363) | TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
type dummy (line 373) | struct dummy {}
type optional_storage_base<T, true> (line 383) | struct optional_storage_base<T, true> {
type dummy (line 393) | struct dummy {}
type optional_operations_base (line 404) | struct optional_operations_base : optional_storage_base<T> {
method hard_reset (line 407) | void hard_reset() noexcept {
method construct (line 412) | void construct(Args &&... args) noexcept {
method assign (line 417) | void assign(Opt &&rhs) {
method has_value (line 432) | bool has_value() const { return this->m_has_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 434) | TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 435) | TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_v...
method TL_OPTIONAL_11_CONSTEXPR (line 436) | TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_v...
method T (line 438) | constexpr const T &&get() const && { return std::move(this->m_valu...
type optional_copy_base (line 445) | struct optional_copy_base : optional_operations_base<T> {
type optional_copy_base<T, false> (line 451) | struct optional_copy_base<T, false> : optional_operations_base<T> {
method optional_copy_base (line 454) | optional_copy_base() = default;
method optional_copy_base (line 455) | optional_copy_base(const optional_copy_base &rhs) {
method optional_copy_base (line 463) | optional_copy_base(optional_copy_base &&rhs) = default;
method optional_copy_base (line 464) | optional_copy_base &operator=(const optional_copy_base &rhs) = def...
method optional_copy_base (line 465) | optional_copy_base &operator=(optional_copy_base &&rhs) = default;
type optional_move_base (line 475) | struct optional_move_base : optional_copy_base<T> {
type optional_move_base (line 479) | struct optional_move_base
type optional_move_base<T, false> (line 481) | struct optional_move_base<T, false> : optional_copy_base<T> {
method optional_move_base (line 484) | optional_move_base() = default;
method optional_move_base (line 485) | optional_move_base(const optional_move_base &rhs) = default;
method optional_move_base (line 487) | optional_move_base(optional_move_base &&rhs) noexcept(
method optional_move_base (line 495) | optional_move_base &operator=(const optional_move_base &rhs) = def...
method optional_move_base (line 496) | optional_move_base &operator=(optional_move_base &&rhs) = default;
type optional_copy_assign_base (line 503) | struct optional_copy_assign_base : optional_move_base<T> {
type optional_copy_assign_base<T, false> (line 508) | struct optional_copy_assign_base<T, false> : optional_move_base<T> {
method optional_copy_assign_base (line 511) | optional_copy_assign_base() = default;
method optional_copy_assign_base (line 512) | optional_copy_assign_base(const optional_copy_assign_base &rhs) = ...
method optional_copy_assign_base (line 514) | optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
method optional_copy_assign_base (line 515) | optional_copy_assign_base &operator=(const optional_copy_assign_ba...
method optional_copy_assign_base (line 519) | optional_copy_assign_base &
type optional_move_assign_base (line 532) | struct optional_move_assign_base : optional_copy_assign_base<T> {
type optional_move_assign_base (line 536) | struct optional_move_assign_base
type optional_move_assign_base<T, false> (line 540) | struct optional_move_assign_base<T, false> : optional_copy_assign_ba...
method optional_move_assign_base (line 543) | optional_move_assign_base() = default;
method optional_move_assign_base (line 544) | optional_move_assign_base(const optional_move_assign_base &rhs) = ...
method optional_move_assign_base (line 546) | optional_move_assign_base(optional_move_assign_base &&rhs) = default;
method optional_move_assign_base (line 548) | optional_move_assign_base &
method optional_move_assign_base (line 551) | optional_move_assign_base &
type optional_delete_ctor_base (line 564) | struct optional_delete_ctor_base {
method optional_delete_ctor_base (line 565) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 566) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 567) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 568) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 570) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, true, false> (line 574) | struct optional_delete_ctor_base<T, true, false> {
method optional_delete_ctor_base (line 575) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 576) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 577) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 578) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 580) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, true> (line 584) | struct optional_delete_ctor_base<T, false, true> {
method optional_delete_ctor_base (line 585) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 586) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 587) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 588) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 590) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, false> (line 594) | struct optional_delete_ctor_base<T, false, false> {
method optional_delete_ctor_base (line 595) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 596) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 597) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 598) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 600) | optional_delete_ctor_base &
type optional_delete_assign_base (line 611) | struct optional_delete_assign_base {
method optional_delete_assign_base (line 612) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 613) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 614) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 616) | optional_delete_assign_base &
method optional_delete_assign_base (line 618) | optional_delete_assign_base &
type optional_delete_assign_base<T, true, false> (line 622) | struct optional_delete_assign_base<T, true, false> {
method optional_delete_assign_base (line 623) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 624) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 625) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 627) | optional_delete_assign_base &
method optional_delete_assign_base (line 629) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, true> (line 633) | struct optional_delete_assign_base<T, false, true> {
method optional_delete_assign_base (line 634) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 635) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 636) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 638) | optional_delete_assign_base &
method optional_delete_assign_base (line 640) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, false> (line 644) | struct optional_delete_assign_base<T, false, false> {
method optional_delete_assign_base (line 645) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 646) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 647) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 649) | optional_delete_assign_base &
method optional_delete_assign_base (line 651) | optional_delete_assign_base &
type nullopt_t (line 658) | struct nullopt_t {
type do_not_use (line 659) | struct do_not_use {}
method nullopt_t (line 660) | constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {}
class bad_optional_access (line 674) | class bad_optional_access : public std::exception {
method bad_optional_access (line 676) | bad_optional_access() = default;
class optional (line 687) | class optional : private detail::optional_move_assign_base<T>,
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1185) | constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)...
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1192) | optional(const optional<U> &rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1202) | explicit optional(const optional<U> &rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1213) | optional(optional<U> &&rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1223) | explicit optional(optional<U> &&rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1235) | optional &operator=(nullopt_t) noexcept {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1260) | optional &operator=(U &&u) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1277) | optional &operator=(const optional<U> &rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1300) | optional &operator=(optional<U> &&rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function T (line 1319) | T &emplace(Args &&... args) {
function emplace (line 1331) | detail::enable_if_t<
function swap (line 1346) | void
function T (line 1367) | constexpr const T *operator->() const {
function TL_OPTIONAL_11_CONSTEXPR (line 1373) | TL_OPTIONAL_11_CONSTEXPR T *operator->() {
function TL_OPTIONAL_11_CONSTEXPR (line 1381) | TL_OPTIONAL_11_CONSTEXPR T &operator*() & { return this->m_value; }
function T (line 1385) | constexpr const T &operator*() const & { return this->m_value; }
function TL_OPTIONAL_11_CONSTEXPR (line 1388) | TL_OPTIONAL_11_CONSTEXPR T &&operator*() && {
function T (line 1394) | constexpr const T &&operator*() const && { return std::move(this->m_va...
function has_value (line 1399) | constexpr bool has_value() const noexcept { return this->m_has_value; }
function TL_OPTIONAL_11_CONSTEXPR (line 1410) | TL_OPTIONAL_11_CONSTEXPR T &value() & {
function TL_OPTIONAL_11_CONSTEXPR (line 1417) | TL_OPTIONAL_11_CONSTEXPR const T &value() const & {
function TL_OPTIONAL_11_CONSTEXPR (line 1423) | TL_OPTIONAL_11_CONSTEXPR T &&value() && {
function TL_OPTIONAL_11_CONSTEXPR (line 1431) | TL_OPTIONAL_11_CONSTEXPR const T &&value() const && {
function T (line 1440) | constexpr T value_or(U &&u) const & {
function TL_OPTIONAL_11_CONSTEXPR (line 1448) | TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && {
function reset (line 1456) | void reset() noexcept {
type tl (line 105) | namespace tl {
type detail (line 66) | namespace detail {
type is_trivially_copy_constructible (line 68) | struct is_trivially_copy_constructible : std::is_trivially_copy_cons...
type is_trivially_copy_constructible<std::vector<T,A>> (line 71) | struct is_trivially_copy_constructible<std::vector<T,A>>
type conjunction (line 136) | struct conjunction : std::true_type {}
type conjunction<B> (line 137) | struct conjunction<B> : B {}
type is_pointer_to_non_const_member_func (line 150) | struct is_pointer_to_non_const_member_func : std::false_type{}
type is_const_or_const_ref (line 164) | struct is_const_or_const_ref : std::false_type{}
type is_const_or_const_ref<T const&> (line 165) | struct is_const_or_const_ref<T const&> : std::true_type{}
type is_const_or_const_ref<T const> (line 166) | struct is_const_or_const_ref<T const> : std::true_type{}
function invoke (line 178) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 186) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 193) | struct invoke_result_impl
type voider (line 210) | struct voider { using type = void; }
type is_optional_impl (line 214) | struct is_optional_impl : std::false_type {}
type is_optional_impl<optional<T>> (line 215) | struct is_optional_impl<optional<T>> : std::true_type {}
type returns_void_impl (line 226) | struct returns_void_impl
type is_swappable (line 283) | struct is_swappable : std::true_type {}
type is_nothrow_swappable (line 285) | struct is_nothrow_swappable : std::true_type {}
type swap_adl_tests (line 288) | namespace swap_adl_tests {
type tag (line 291) | struct tag {}
type is_std_swap_noexcept (line 310) | struct is_std_swap_noexcept
type is_std_swap_noexcept<T[N]> (line 316) | struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}
type is_adl_swap_noexcept (line 319) | struct is_adl_swap_noexcept
type is_swappable (line 324) | struct is_swappable
type is_swappable<T[N], T[N]> (line 333) | struct is_swappable<T[N], T[N]>
type is_nothrow_swappable (line 342) | struct is_nothrow_swappable
type optional_storage_base (line 358) | struct optional_storage_base {
method TL_OPTIONAL_11_CONSTEXPR (line 363) | TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
type dummy (line 373) | struct dummy {}
type optional_storage_base<T, true> (line 383) | struct optional_storage_base<T, true> {
type dummy (line 393) | struct dummy {}
type optional_operations_base (line 404) | struct optional_operations_base : optional_storage_base<T> {
method hard_reset (line 407) | void hard_reset() noexcept {
method construct (line 412) | void construct(Args &&... args) noexcept {
method assign (line 417) | void assign(Opt &&rhs) {
method has_value (line 432) | bool has_value() const { return this->m_has_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 434) | TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 435) | TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_v...
method TL_OPTIONAL_11_CONSTEXPR (line 436) | TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_v...
method T (line 438) | constexpr const T &&get() const && { return std::move(this->m_valu...
type optional_copy_base (line 445) | struct optional_copy_base : optional_operations_base<T> {
type optional_copy_base<T, false> (line 451) | struct optional_copy_base<T, false> : optional_operations_base<T> {
method optional_copy_base (line 454) | optional_copy_base() = default;
method optional_copy_base (line 455) | optional_copy_base(const optional_copy_base &rhs) {
method optional_copy_base (line 463) | optional_copy_base(optional_copy_base &&rhs) = default;
method optional_copy_base (line 464) | optional_copy_base &operator=(const optional_copy_base &rhs) = def...
method optional_copy_base (line 465) | optional_copy_base &operator=(optional_copy_base &&rhs) = default;
type optional_move_base (line 475) | struct optional_move_base : optional_copy_base<T> {
type optional_move_base (line 479) | struct optional_move_base
type optional_move_base<T, false> (line 481) | struct optional_move_base<T, false> : optional_copy_base<T> {
method optional_move_base (line 484) | optional_move_base() = default;
method optional_move_base (line 485) | optional_move_base(const optional_move_base &rhs) = default;
method optional_move_base (line 487) | optional_move_base(optional_move_base &&rhs) noexcept(
method optional_move_base (line 495) | optional_move_base &operator=(const optional_move_base &rhs) = def...
method optional_move_base (line 496) | optional_move_base &operator=(optional_move_base &&rhs) = default;
type optional_copy_assign_base (line 503) | struct optional_copy_assign_base : optional_move_base<T> {
type optional_copy_assign_base<T, false> (line 508) | struct optional_copy_assign_base<T, false> : optional_move_base<T> {
method optional_copy_assign_base (line 511) | optional_copy_assign_base() = default;
method optional_copy_assign_base (line 512) | optional_copy_assign_base(const optional_copy_assign_base &rhs) = ...
method optional_copy_assign_base (line 514) | optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
method optional_copy_assign_base (line 515) | optional_copy_assign_base &operator=(const optional_copy_assign_ba...
method optional_copy_assign_base (line 519) | optional_copy_assign_base &
type optional_move_assign_base (line 532) | struct optional_move_assign_base : optional_copy_assign_base<T> {
type optional_move_assign_base (line 536) | struct optional_move_assign_base
type optional_move_assign_base<T, false> (line 540) | struct optional_move_assign_base<T, false> : optional_copy_assign_ba...
method optional_move_assign_base (line 543) | optional_move_assign_base() = default;
method optional_move_assign_base (line 544) | optional_move_assign_base(const optional_move_assign_base &rhs) = ...
method optional_move_assign_base (line 546) | optional_move_assign_base(optional_move_assign_base &&rhs) = default;
method optional_move_assign_base (line 548) | optional_move_assign_base &
method optional_move_assign_base (line 551) | optional_move_assign_base &
type optional_delete_ctor_base (line 564) | struct optional_delete_ctor_base {
method optional_delete_ctor_base (line 565) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 566) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 567) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 568) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 570) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, true, false> (line 574) | struct optional_delete_ctor_base<T, true, false> {
method optional_delete_ctor_base (line 575) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 576) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 577) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 578) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 580) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, true> (line 584) | struct optional_delete_ctor_base<T, false, true> {
method optional_delete_ctor_base (line 585) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 586) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 587) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 588) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 590) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, false> (line 594) | struct optional_delete_ctor_base<T, false, false> {
method optional_delete_ctor_base (line 595) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 596) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 597) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 598) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 600) | optional_delete_ctor_base &
type optional_delete_assign_base (line 611) | struct optional_delete_assign_base {
method optional_delete_assign_base (line 612) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 613) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 614) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 616) | optional_delete_assign_base &
method optional_delete_assign_base (line 618) | optional_delete_assign_base &
type optional_delete_assign_base<T, true, false> (line 622) | struct optional_delete_assign_base<T, true, false> {
method optional_delete_assign_base (line 623) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 624) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 625) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 627) | optional_delete_assign_base &
method optional_delete_assign_base (line 629) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, true> (line 633) | struct optional_delete_assign_base<T, false, true> {
method optional_delete_assign_base (line 634) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 635) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 636) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 638) | optional_delete_assign_base &
method optional_delete_assign_base (line 640) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, false> (line 644) | struct optional_delete_assign_base<T, false, false> {
method optional_delete_assign_base (line 645) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 646) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 647) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 649) | optional_delete_assign_base &
method optional_delete_assign_base (line 651) | optional_delete_assign_base &
class monostate (line 109) | class monostate {}
type in_place_t (line 112) | struct in_place_t {
method in_place_t (line 113) | explicit in_place_t() = default;
class optional (line 119) | class optional
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
type detail (line 122) | namespace detail {
type is_trivially_copy_constructible (line 68) | struct is_trivially_copy_constructible : std::is_trivially_copy_cons...
type is_trivially_copy_constructible<std::vector<T,A>> (line 71) | struct is_trivially_copy_constructible<std::vector<T,A>>
type conjunction (line 136) | struct conjunction : std::true_type {}
type conjunction<B> (line 137) | struct conjunction<B> : B {}
type is_pointer_to_non_const_member_func (line 150) | struct is_pointer_to_non_const_member_func : std::false_type{}
type is_const_or_const_ref (line 164) | struct is_const_or_const_ref : std::false_type{}
type is_const_or_const_ref<T const&> (line 165) | struct is_const_or_const_ref<T const&> : std::true_type{}
type is_const_or_const_ref<T const> (line 166) | struct is_const_or_const_ref<T const> : std::true_type{}
function invoke (line 178) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
function invoke (line 186) | constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
type invoke_result_impl (line 193) | struct invoke_result_impl
type voider (line 210) | struct voider { using type = void; }
type is_optional_impl (line 214) | struct is_optional_impl : std::false_type {}
type is_optional_impl<optional<T>> (line 215) | struct is_optional_impl<optional<T>> : std::true_type {}
type returns_void_impl (line 226) | struct returns_void_impl
type is_swappable (line 283) | struct is_swappable : std::true_type {}
type is_nothrow_swappable (line 285) | struct is_nothrow_swappable : std::true_type {}
type swap_adl_tests (line 288) | namespace swap_adl_tests {
type tag (line 291) | struct tag {}
type is_std_swap_noexcept (line 310) | struct is_std_swap_noexcept
type is_std_swap_noexcept<T[N]> (line 316) | struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {}
type is_adl_swap_noexcept (line 319) | struct is_adl_swap_noexcept
type is_swappable (line 324) | struct is_swappable
type is_swappable<T[N], T[N]> (line 333) | struct is_swappable<T[N], T[N]>
type is_nothrow_swappable (line 342) | struct is_nothrow_swappable
type optional_storage_base (line 358) | struct optional_storage_base {
method TL_OPTIONAL_11_CONSTEXPR (line 363) | TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U &&... u)
type dummy (line 373) | struct dummy {}
type optional_storage_base<T, true> (line 383) | struct optional_storage_base<T, true> {
type dummy (line 393) | struct dummy {}
type optional_operations_base (line 404) | struct optional_operations_base : optional_storage_base<T> {
method hard_reset (line 407) | void hard_reset() noexcept {
method construct (line 412) | void construct(Args &&... args) noexcept {
method assign (line 417) | void assign(Opt &&rhs) {
method has_value (line 432) | bool has_value() const { return this->m_has_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 434) | TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 435) | TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_v...
method TL_OPTIONAL_11_CONSTEXPR (line 436) | TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_v...
method T (line 438) | constexpr const T &&get() const && { return std::move(this->m_valu...
type optional_copy_base (line 445) | struct optional_copy_base : optional_operations_base<T> {
type optional_copy_base<T, false> (line 451) | struct optional_copy_base<T, false> : optional_operations_base<T> {
method optional_copy_base (line 454) | optional_copy_base() = default;
method optional_copy_base (line 455) | optional_copy_base(const optional_copy_base &rhs) {
method optional_copy_base (line 463) | optional_copy_base(optional_copy_base &&rhs) = default;
method optional_copy_base (line 464) | optional_copy_base &operator=(const optional_copy_base &rhs) = def...
method optional_copy_base (line 465) | optional_copy_base &operator=(optional_copy_base &&rhs) = default;
type optional_move_base (line 475) | struct optional_move_base : optional_copy_base<T> {
type optional_move_base (line 479) | struct optional_move_base
type optional_move_base<T, false> (line 481) | struct optional_move_base<T, false> : optional_copy_base<T> {
method optional_move_base (line 484) | optional_move_base() = default;
method optional_move_base (line 485) | optional_move_base(const optional_move_base &rhs) = default;
method optional_move_base (line 487) | optional_move_base(optional_move_base &&rhs) noexcept(
method optional_move_base (line 495) | optional_move_base &operator=(const optional_move_base &rhs) = def...
method optional_move_base (line 496) | optional_move_base &operator=(optional_move_base &&rhs) = default;
type optional_copy_assign_base (line 503) | struct optional_copy_assign_base : optional_move_base<T> {
type optional_copy_assign_base<T, false> (line 508) | struct optional_copy_assign_base<T, false> : optional_move_base<T> {
method optional_copy_assign_base (line 511) | optional_copy_assign_base() = default;
method optional_copy_assign_base (line 512) | optional_copy_assign_base(const optional_copy_assign_base &rhs) = ...
method optional_copy_assign_base (line 514) | optional_copy_assign_base(optional_copy_assign_base &&rhs) = default;
method optional_copy_assign_base (line 515) | optional_copy_assign_base &operator=(const optional_copy_assign_ba...
method optional_copy_assign_base (line 519) | optional_copy_assign_base &
type optional_move_assign_base (line 532) | struct optional_move_assign_base : optional_copy_assign_base<T> {
type optional_move_assign_base (line 536) | struct optional_move_assign_base
type optional_move_assign_base<T, false> (line 540) | struct optional_move_assign_base<T, false> : optional_copy_assign_ba...
method optional_move_assign_base (line 543) | optional_move_assign_base() = default;
method optional_move_assign_base (line 544) | optional_move_assign_base(const optional_move_assign_base &rhs) = ...
method optional_move_assign_base (line 546) | optional_move_assign_base(optional_move_assign_base &&rhs) = default;
method optional_move_assign_base (line 548) | optional_move_assign_base &
method optional_move_assign_base (line 551) | optional_move_assign_base &
type optional_delete_ctor_base (line 564) | struct optional_delete_ctor_base {
method optional_delete_ctor_base (line 565) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 566) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 567) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 568) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 570) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, true, false> (line 574) | struct optional_delete_ctor_base<T, true, false> {
method optional_delete_ctor_base (line 575) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 576) | optional_delete_ctor_base(const optional_delete_ctor_base &) = def...
method optional_delete_ctor_base (line 577) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 578) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 580) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, true> (line 584) | struct optional_delete_ctor_base<T, false, true> {
method optional_delete_ctor_base (line 585) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 586) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 587) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 588) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 590) | optional_delete_ctor_base &
type optional_delete_ctor_base<T, false, false> (line 594) | struct optional_delete_ctor_base<T, false, false> {
method optional_delete_ctor_base (line 595) | optional_delete_ctor_base() = default;
method optional_delete_ctor_base (line 596) | optional_delete_ctor_base(const optional_delete_ctor_base &) = del...
method optional_delete_ctor_base (line 597) | optional_delete_ctor_base(optional_delete_ctor_base &&) noexcept =...
method optional_delete_ctor_base (line 598) | optional_delete_ctor_base &
method optional_delete_ctor_base (line 600) | optional_delete_ctor_base &
type optional_delete_assign_base (line 611) | struct optional_delete_assign_base {
method optional_delete_assign_base (line 612) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 613) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 614) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 616) | optional_delete_assign_base &
method optional_delete_assign_base (line 618) | optional_delete_assign_base &
type optional_delete_assign_base<T, true, false> (line 622) | struct optional_delete_assign_base<T, true, false> {
method optional_delete_assign_base (line 623) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 624) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 625) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 627) | optional_delete_assign_base &
method optional_delete_assign_base (line 629) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, true> (line 633) | struct optional_delete_assign_base<T, false, true> {
method optional_delete_assign_base (line 634) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 635) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 636) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 638) | optional_delete_assign_base &
method optional_delete_assign_base (line 640) | optional_delete_assign_base &
type optional_delete_assign_base<T, false, false> (line 644) | struct optional_delete_assign_base<T, false, false> {
method optional_delete_assign_base (line 645) | optional_delete_assign_base() = default;
method optional_delete_assign_base (line 646) | optional_delete_assign_base(const optional_delete_assign_base &) =...
method optional_delete_assign_base (line 647) | optional_delete_assign_base(optional_delete_assign_base &&) noexce...
method optional_delete_assign_base (line 649) | optional_delete_assign_base &
method optional_delete_assign_base (line 651) | optional_delete_assign_base &
type nullopt_t (line 658) | struct nullopt_t {
type do_not_use (line 659) | struct do_not_use {}
method nullopt_t (line 660) | constexpr explicit nullopt_t(do_not_use, do_not_use) noexcept {}
class bad_optional_access (line 674) | class bad_optional_access : public std::exception {
method bad_optional_access (line 676) | bad_optional_access() = default;
class optional (line 687) | class optional : private detail::optional_move_assign_base<T>,
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1185) | constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)...
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1192) | optional(const optional<U> &rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1202) | explicit optional(const optional<U> &rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1213) | optional(optional<U> &&rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1223) | explicit optional(optional<U> &&rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1235) | optional &operator=(nullopt_t) noexcept {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1260) | optional &operator=(U &&u) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1277) | optional &operator=(const optional<U> &rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function optional (line 1300) | optional &operator=(optional<U> &&rhs) {
method and_then (line 714) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 725) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 736) | constexpr auto and_then(F &&f) const & {
method and_then (line 748) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 769) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F ...
method TL_OPTIONAL_11_CONSTEXPR (line 781) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &&> and_then(F...
method and_then (line 793) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) cons...
method and_then (line 806) | constexpr detail::invoke_result_t<F, const T &&> and_then(F &&f) con...
method map (line 828) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 834) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 840) | constexpr auto map(F &&f) const & {
method map (line 846) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 860) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method TL_OPTIONAL_11_CONSTEXPR (line 869) | TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<opt...
method map (line 878) | constexpr decltype(optional_map_impl(std::declval<const optional &>(),
method map (line 888) | constexpr decltype(optional_map_impl(std::declval<const optional &&>(),
method or_else (line 923) | optional<T> or_else(F &&f) && {
method or_else (line 940) | optional<T> or_else(F &&f) const & {
method or_else (line 957) | optional<T> or_else(F &&f) const && {
method or_else (line 967) | optional<T> or_else(F &&f) const && {
method U (line 979) | U map_or(F &&f, U &&u) & {
method U (line 985) | U map_or(F &&f, U &&u) && {
method U (line 991) | U map_or(F &&f, U &&u) const & {
method U (line 998) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 1014) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 1023) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 1032) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 1042) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 1050) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) ...
method TL_OPTIONAL_11_CONSTEXPR (line 1057) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 1062) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1067) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 1073) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1079) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 1084) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 1089) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 1095) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 1102) | optional take() & {
method optional (line 1109) | optional take() const & {
method optional (line 1116) | optional take() && {
method optional (line 1124) | optional take() const && {
method optional (line 1135) | constexpr optional() noexcept = default;
method optional (line 1138) | constexpr optional(nullopt_t) noexcept {}
method TL_OPTIONAL_11_CONSTEXPR (line 1144) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) = default;
method TL_OPTIONAL_11_CONSTEXPR (line 1150) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 1156) | constexpr explicit optional(
function T (line 1319) | T &emplace(Args &&... args) {
function emplace (line 1331) | detail::enable_if_t<
function swap (line 1346) | void
function T (line 1367) | constexpr const T *operator->() const {
function TL_OPTIONAL_11_CONSTEXPR (line 1373) | TL_OPTIONAL_11_CONSTEXPR T *operator->() {
function TL_OPTIONAL_11_CONSTEXPR (line 1381) | TL_OPTIONAL_11_CONSTEXPR T &operator*() & { return this->m_value; }
function T (line 1385) | constexpr const T &operator*() const & { return this->m_value; }
function TL_OPTIONAL_11_CONSTEXPR (line 1388) | TL_OPTIONAL_11_CONSTEXPR T &&operator*() && {
function T (line 1394) | constexpr const T &&operator*() const && { return std::move(this->m_va...
function has_value (line 1399) | constexpr bool has_value() const noexcept { return this->m_has_value; }
function TL_OPTIONAL_11_CONSTEXPR (line 1410) | TL_OPTIONAL_11_CONSTEXPR T &value() & {
function TL_OPTIONAL_11_CONSTEXPR (line 1417) | TL_OPTIONAL_11_CONSTEXPR const T &value() const & {
function TL_OPTIONAL_11_CONSTEXPR (line 1423) | TL_OPTIONAL_11_CONSTEXPR T &&value() && {
function TL_OPTIONAL_11_CONSTEXPR (line 1431) | TL_OPTIONAL_11_CONSTEXPR const T &&value() const && {
function T (line 1440) | constexpr T value_or(U &&u) const & {
function TL_OPTIONAL_11_CONSTEXPR (line 1448) | TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && {
function reset (line 1456) | void reset() noexcept {
type conjunction<B, Bs...> (line 139) | struct conjunction<B, Bs...>
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...)> (line 152) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)> : std::...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&> (line 154) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&> : std:...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&&> (line 156) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...)&&> : std...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile> (line 158) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&> (line 160) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile...
type is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile&&> (line 162) | struct is_pointer_to_non_const_member_func<Ret (T::*) (Args...) volatile...
type invoke_result_impl<
F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
Us...> (line 196) | struct invoke_result_impl<
type returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...> (line 228) | struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...>
function swap (line 1640) | void swap(optional<T> &lhs,
type detail (line 1645) | namespace detail {
type i_am_secret (line 1646) | struct i_am_secret {}
function optional_map_impl (line 1678) | constexpr auto optional_map_impl(Opt &&opt, F &&f) {
function optional_map_impl (line 1688) | auto optional_map_impl(Opt &&opt, F &&f) {
function optional_map_impl (line 1702) | constexpr auto optional_map_impl(Opt &&opt, F &&f) -> optional<Ret> {
function optional_map_impl (line 1713) | auto optional_map_impl(Opt &&opt, F &&f) -> optional<monostate> {
function make_optional (line 1653) | inline constexpr optional<Ret> make_optional(U &&v) {
function make_optional (line 1658) | inline constexpr optional<T> make_optional(Args &&... args) {
function make_optional (line 1662) | inline constexpr optional<T> make_optional(std::initializer_list<U> il,
type detail (line 1672) | namespace detail {
type i_am_secret (line 1646) | struct i_am_secret {}
function optional_map_impl (line 1678) | constexpr auto optional_map_impl(Opt &&opt, F &&f) {
function optional_map_impl (line 1688) | auto optional_map_impl(Opt &&opt, F &&f) {
function optional_map_impl (line 1702) | constexpr auto optional_map_impl(Opt &&opt, F &&f) -> optional<Ret> {
function optional_map_impl (line 1713) | auto optional_map_impl(Opt &&opt, F &&f) -> optional<monostate> {
class optional<T &> (line 1746) | class optional<T &> {
method and_then (line 1764) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) & {
method and_then (line 1775) | TL_OPTIONAL_11_CONSTEXPR auto and_then(F &&f) && {
method and_then (line 1786) | constexpr auto and_then(F &&f) const & {
method and_then (line 1798) | constexpr auto and_then(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1819) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&...
method TL_OPTIONAL_11_CONSTEXPR (line 1831) | TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T &> and_then(F &&...
method and_then (line 1843) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const & {
method and_then (line 1856) | constexpr detail::invoke_result_t<F, const T &> and_then(F &&f) const ...
method map (line 1878) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) & {
method map (line 1884) | TL_OPTIONAL_11_CONSTEXPR auto map(F &&f) && {
method map (line 1890) | constexpr auto map(F &&f) const & {
method map (line 1896) | constexpr auto map(F &&f) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 1910) | TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declv...
method TL_OPTIONAL_11_CONSTEXPR (line 1919) | TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declv...
method map (line 1928) | constexpr decltype(detail::optional_map_impl(std::declval<const option...
method map (line 1938) | constexpr decltype(detail::optional_map_impl(std::declval<const option...
method or_else (line 1972) | optional<T> or_else(F &&f) && {
method or_else (line 1989) | optional<T> or_else(F &&f) const & {
method or_else (line 2006) | optional<T> or_else(F &&f) const && {
method or_else (line 2016) | optional<T> or_else(F &&f) const && {
method U (line 2028) | U map_or(F &&f, U &&u) & {
method U (line 2034) | U map_or(F &&f, U &&u) && {
method U (line 2040) | U map_or(F &&f, U &&u) const & {
method U (line 2047) | U map_or(F &&f, U &&u) const && {
method map_or_else (line 2063) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) & {
method map_or_else (line 2072) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) && {
method map_or_else (line 2081) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const & {
method map_or_else (line 2091) | detail::invoke_result_t<U> map_or_else(F &&f, U &&u) const && {
method conjunction (line 2099) | constexpr optional<typename std::decay<U>::type> conjunction(U &&u) co...
method TL_OPTIONAL_11_CONSTEXPR (line 2106) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) & {
method optional (line 2111) | constexpr optional disjunction(const optional &rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 2116) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional &rhs) && {
method optional (line 2122) | constexpr optional disjunction(const optional &rhs) const && {
method TL_OPTIONAL_11_CONSTEXPR (line 2128) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) & {
method optional (line 2133) | constexpr optional disjunction(optional &&rhs) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 2138) | TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional &&rhs) && {
method optional (line 2144) | constexpr optional disjunction(optional &&rhs) const && {
method optional (line 2151) | optional take() & {
method optional (line 2158) | optional take() const & {
method optional (line 2165) | optional take() && {
method optional (line 2173) | optional take() const && {
method optional (line 2184) | constexpr optional() noexcept : m_value(nullptr) {}
method optional (line 2187) | constexpr optional(nullopt_t) noexcept : m_value(nullptr) {}
method TL_OPTIONAL_11_CONSTEXPR (line 2193) | TL_OPTIONAL_11_CONSTEXPR optional(const optional &rhs) noexcept = defa...
method TL_OPTIONAL_11_CONSTEXPR (line 2199) | TL_OPTIONAL_11_CONSTEXPR optional(optional &&rhs) = default;
method optional (line 2206) | constexpr optional(U &&u) : m_value(std::addressof(u)) {
method optional (line 2212) | constexpr explicit optional(const optional<U> &rhs) : optional(*rhs) {}
method optional (line 2220) | optional &operator=(nullopt_t) noexcept {
method optional (line 2229) | optional &operator=(const optional &rhs) = default;
method optional (line 2238) | optional &operator=(U &&u) {
method optional (line 2248) | optional &operator=(const optional<U> &rhs) {
method T (line 2257) | T &emplace(Args &&... args) noexcept {
method swap (line 2272) | void swap(optional &rhs) noexcept { std::swap(m_value, rhs.m_value); }
method T (line 2278) | constexpr const T *operator->() const { return m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 2282) | TL_OPTIONAL_11_CONSTEXPR T *operator->() { return m_value; }
method TL_OPTIONAL_11_CONSTEXPR (line 2288) | TL_OPTIONAL_11_CONSTEXPR T &operator*() { return *m_value; }
method T (line 2292) | constexpr const T &operator*() const { return *m_value; }
method has_value (line 2296) | constexpr bool has_value() const noexcept { return m_value != nullptr; }
method TL_OPTIONAL_11_CONSTEXPR (line 2307) | TL_OPTIONAL_11_CONSTEXPR T &value() {
method TL_OPTIONAL_11_CONSTEXPR (line 2314) | TL_OPTIONAL_11_CONSTEXPR const T &value() const {
method T (line 2322) | constexpr T value_or(U &&u) const & {
method TL_OPTIONAL_11_CONSTEXPR (line 2330) | TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && {
method reset (line 2338) | void reset() noexcept { m_value = nullptr; }
type std (line 2348) | namespace std {
type hash<tl::optional<T>> (line 2350) | struct hash<tl::optional<T>> {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/ordered-map/include/tsl/ordered_hash.h
function namespace (line 82) | namespace tsl {
function iterator (line 469) | iterator begin() noexcept {
function const_iterator (line 473) | const_iterator begin() const noexcept {
function iterator (line 481) | iterator end() noexcept {
function const_iterator (line 485) | const_iterator end() const noexcept {
function reverse_iterator (line 494) | reverse_iterator rbegin() noexcept {
function const_reverse_iterator (line 498) | const_reverse_iterator rbegin() const noexcept {
function reverse_iterator (line 506) | reverse_iterator rend() noexcept {
function const_reverse_iterator (line 510) | const_reverse_iterator rend() const noexcept {
function size_type (line 530) | size_type max_size() const noexcept {
function iterator (line 640) | iterator erase(iterator pos) {
function iterator (line 644) | iterator erase(const_iterator pos) {
function iterator (line 661) | iterator erase(const_iterator first, const_iterator last) {
function hash (line 713) | size_t hash) {
function swap (line 717) | void swap(ordered_hash& other) {
function typename (line 748) | typename U::value_type& at(const K& key) const {
function typename (line 753) | typename U::value_type& at(const K& key, std::size_t hash) const {
function max_load_factor (line 857) | void max_load_factor(float ml) {
function rehash (line 862) | void rehash(size_type count) {
function reserve (line 867) | void reserve(size_type count) {
function iterator (line 890) | iterator mutable_iterator(const_iterator pos) {
function iterator (line 894) | iterator nth(size_type index) {
function const_iterator (line 899) | const_iterator nth(size_type index) const {
function values_container_type (line 914) | const values_container_type& values_container() const noexcept {
function shrink_to_fit (line 928) | void shrink_to_fit() {
function pop_back (line 952) | void pop_back() {
function iterator (line 962) | iterator unordered_erase(iterator pos) {
function iterator (line 966) | iterator unordered_erase(const_iterator pos) {
function rehash_impl (line 1077) | void rehash_impl(size_type bucket_count) {
function reserve_space_for_values (line 1137) | reserve_space_for_values(size_type /*count*/) {
function backward_shift (line 1144) | void backward_shift(std::size_t empty_ibucket) noexcept {
function erase_value_from_bucket (line 1156) | void erase_value_from_bucket(typename buckets_container_type::iterator i...
function shift_indexes_in_buckets (line 1178) | void shift_indexes_in_buckets(index_type from_ivalue, char delta) noexce...
function insert_index (line 1304) | void insert_index(std::size_t ibucket, std::size_t dist_from_ideal_bucket,
function grow_on_high_load (line 1369) | bool grow_on_high_load() {
function round_up_to_power_of_two (line 1381) | static std::size_t round_up_to_power_of_two(std::size_t value) {
function is_power_of_two (line 1398) | static constexpr bool is_power_of_two(std::size_t value) {
function bucket_entry (line 1415) | bucket_entry* static_empty_bucket_ptr() {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/ordered-map/include/tsl/ordered_map.h
function namespace (line 40) | namespace tsl {
function iterator (line 226) | iterator begin() noexcept { return m_ht.begin(); }
function iterator (line 230) | iterator end() noexcept { return m_ht.end(); }
function reverse_iterator (line 234) | reverse_iterator rbegin() noexcept { return m_ht.rbegin(); }
function reverse_iterator (line 238) | reverse_iterator rend() noexcept { return m_ht.rend(); }
function clear (line 253) | void clear() noexcept { m_ht.clear(); }
function iterator (line 265) | iterator insert(const_iterator hint, const value_type& value) {
function iterator (line 274) | iterator insert(const_iterator hint, value_type&& value) {
function insert (line 281) | void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist...
function iterator (line 360) | iterator erase(iterator pos) { return m_ht.erase(pos); }
function iterator (line 365) | iterator erase(const_iterator pos) { return m_ht.erase(pos); }
function iterator (line 370) | iterator erase(const_iterator first, const_iterator last) { return m_ht....
function size_type (line 375) | size_type erase(const key_type& key) { return m_ht.erase(key); }
function size_type (line 383) | size_type erase(const key_type& key, std::size_t precalculated_hash) {
function precalculated_hash (line 403) | size_t precalculated_hash) {
function swap (line 409) | void swap(ordered_map& other) { other.m_ht.swap(m_ht); }
function T (line 423) | const T& at(const Key& key) const { return m_ht.at(key); }
function T (line 428) | const T& at(const Key& key, std::size_t precalculated_hash) const { retu...
function size_type (line 466) | size_type count(const Key& key) const { return m_ht.count(key); }
function size_type (line 472) | size_type count(const Key& key, std::size_t precalculated_hash) const {
function iterator (line 496) | iterator find(const Key& key) { return m_ht.find(key); }
function iterator (line 502) | iterator find(const Key& key, std::size_t precalculated_hash) { return m...
function const_iterator (line 504) | const_iterator find(const Key& key) const { return m_ht.find(key); }
function const_iterator (line 509) | const_iterator find(const Key& key, std::size_t precalculated_hash) const {
function precalculated_hash (line 527) | size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
function max_load_factor (line 613) | void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
function rehash (line 615) | void rehash(size_type count) { m_ht.rehash(count); }
function reserve (line 616) | void reserve(size_type count) { m_ht.reserve(count); }
function iterator (line 634) | iterator mutable_iterator(const_iterator pos) {
function iterator (line 643) | iterator nth(size_type index) { return m_ht.nth(index); }
function const_iterator (line 648) | const_iterator nth(size_type index) const { return m_ht.nth(index); }
function typename (line 666) | typename values_container_type::value_type* data() const noexcept { retu...
function shrink_to_fit (line 677) | void shrink_to_fit() { m_ht.shrink_to_fit(); }
function pop_back (line 727) | void pop_back() { m_ht.pop_back(); }
function iterator (line 734) | iterator unordered_erase(iterator pos) { return m_ht.unordered_erase(pos...
function iterator (line 739) | iterator unordered_erase(const_iterator pos) { return m_ht.unordered_era...
function size_type (line 744) | size_type unordered_erase(const key_type& key) { return m_ht.unordered_e...
function size_type (line 752) | size_type unordered_erase(const key_type& key, std::size_t precalculated...
function precalculated_hash (line 772) | size_t precalculated_hash) {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/ordered-map/include/tsl/ordered_set.h
function namespace (line 40) | namespace tsl {
function iterator (line 209) | iterator begin() noexcept { return m_ht.begin(); }
function iterator (line 213) | iterator end() noexcept { return m_ht.end(); }
function reverse_iterator (line 217) | reverse_iterator rbegin() noexcept { return m_ht.rbegin(); }
function reverse_iterator (line 221) | reverse_iterator rend() noexcept { return m_ht.rend(); }
function clear (line 236) | void clear() noexcept { m_ht.clear(); }
function iterator (line 243) | iterator insert(const_iterator hint, const value_type& value) {
function iterator (line 247) | iterator insert(const_iterator hint, value_type&& value) {
function insert (line 253) | void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist...
function iterator (line 284) | iterator erase(iterator pos) { return m_ht.erase(pos); }
function iterator (line 289) | iterator erase(const_iterator pos) { return m_ht.erase(pos); }
function iterator (line 294) | iterator erase(const_iterator first, const_iterator last) { return m_ht....
function size_type (line 299) | size_type erase(const key_type& key) { return m_ht.erase(key); }
function size_type (line 307) | size_type erase(const key_type& key, std::size_t precalculated_hash) {
function precalculated_hash (line 327) | size_t precalculated_hash) {
function swap (line 333) | void swap(ordered_set& other) { other.m_ht.swap(m_ht); }
function size_type (line 338) | size_type count(const Key& key) const { return m_ht.count(key); }
function size_type (line 344) | size_type count(const Key& key, std::size_t precalculated_hash) const {
function iterator (line 369) | iterator find(const Key& key) { return m_ht.find(key); }
function iterator (line 375) | iterator find(const Key& key, std::size_t precalculated_hash) { return m...
function const_iterator (line 377) | const_iterator find(const Key& key) const { return m_ht.find(key); }
function const_iterator (line 382) | const_iterator find(const Key& key, std::size_t precalculated_hash) const {
function precalculated_hash (line 400) | size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
function max_load_factor (line 485) | void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
function rehash (line 487) | void rehash(size_type count) { m_ht.rehash(count); }
function reserve (line 488) | void reserve(size_type count) { m_ht.reserve(count); }
function iterator (line 505) | iterator mutable_iterator(const_iterator pos) {
function iterator (line 514) | iterator nth(size_type index) { return m_ht.nth(index); }
function const_iterator (line 519) | const_iterator nth(size_type index) const { return m_ht.nth(index); }
function typename (line 537) | typename values_container_type::value_type* data() const noexcept { retu...
function shrink_to_fit (line 548) | void shrink_to_fit() { m_ht.shrink_to_fit(); }
function pop_back (line 582) | void pop_back() { m_ht.pop_back(); }
function iterator (line 589) | iterator unordered_erase(iterator pos) { return m_ht.unordered_erase(pos...
function iterator (line 594) | iterator unordered_erase(const_iterator pos) { return m_ht.unordered_era...
function size_type (line 599) | size_type unordered_erase(const key_type& key) { return m_ht.unordered_e...
function size_type (line 607) | size_type unordered_erase(const key_type& key, std::size_t precalculated...
function precalculated_hash (line 627) | size_t precalculated_hash) {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/async.h
function namespace (line 25) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/async_logger-inl.h
function SPDLOG_INLINE (line 16) | SPDLOG_INLINE spdlog::async_logger::async_logger(
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/async_logger.h
type class (line 27) | enum class
function namespace (line 34) | namespace details {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/cfg/argv.h
function namespace (line 20) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/cfg/env.h
function namespace (line 26) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/cfg/helpers-inl.h
function namespace (line 19) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/cfg/helpers.h
function namespace (line 9) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/cfg/log_levels.h
function namespace (line 10) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/common-inl.h
function namespace (line 13) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/common.h
function namespace (line 116) | namespace sinks {
function namespace (line 215) | namespace level {
type class (line 261) | enum class
type class (line 272) | enum class
type source_loc (line 295) | struct source_loc
function line (line 309) | int line{0}
type file_event_handlers (line 313) | struct file_event_handlers
function namespace (line 321) | namespace details {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/backtracer-inl.h
function namespace (line 10) | namespace details {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/backtracer.h
function namespace (line 21) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/circular_q.h
function namespace (line 10) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/console_globals.h
function namespace (line 9) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/file_helper-inl.h
function namespace (line 20) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/file_helper.h
function namespace (line 14) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/fmt_helper.h
function namespace (line 17) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/log_msg-inl.h
function namespace (line 12) | namespace spdlog {
FILE: src/cpp/RiderLink/Source/RD/thirdparty/spdlog/include/spdlog/details/log_msg.h
function namespace (line 14) | namespace spdlog {
FILE: s
Condensed preview — 490 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,437K chars).
[
{
"path": ".editorconfig",
"chars": 77,
"preview": "root = true\n\n[*.{csproj,props,targets}]\nindent_style = space\nindent_size = 2\n"
},
{
"path": ".gitattributes",
"chars": 193,
"preview": "# Set the default behavior, in case people don't have core.autocrlf set.\n* text=auto\n\n# Keep LF in shell scripts\n*.sh te"
},
{
"path": ".github/workflows/build.yml",
"chars": 1535,
"preview": "name: Build UnrealLink\non:\n push:\n branches: [ 'net212**' ]\n paths-ignore:\n - src/rider/test\n - testDat"
},
{
"path": ".gitignore",
"chars": 1057,
"preview": "# Build artifacts\n[Bb]in/\n[Oo]bj/\nbuild\noutput\n.gradle\n.tmp\nout/*\n*.generated.*\nNuGet.Config\n\n# User-specific files\n*.su"
},
{
"path": ".run/Debug backend.run.xml",
"chars": 640,
"preview": "<component name=\"ProjectRunConfigurationManager\">\n <configuration default=\"false\" name=\"Debug backend\" type=\"RunNativeE"
},
{
"path": ".run/UnrealLink [runIde].run.xml",
"chars": 948,
"preview": "<component name=\"ProjectRunConfigurationManager\">\n <configuration default=\"false\" name=\"UnrealLink [runIde]\" type=\"Grad"
},
{
"path": "CHANGELOG.md",
"chars": 17377,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 268,
"preview": "## Code of Conduct\n\nThis project and the corresponding community is governed by the [JetBrains Open Source and Community"
},
{
"path": "License.txt",
"chars": 11363,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "README.md",
"chars": 7287,
"preview": "[](https://confluence.jetbrains.com/display/"
},
{
"path": "SETUP.md",
"chars": 2062,
"preview": "<h1>Setting up development environment</h1>\n\n<p>After cloning the repository, you need to perform some actions to set up"
},
{
"path": "SdkBasedPluginEmbedding.Root",
"chars": 0,
"preview": ""
},
{
"path": "SubplatformsCollection.Root",
"chars": 0,
"preview": ""
},
{
"path": "UnrealLink.sln",
"chars": 1538,
"preview": "\nMicrosoft Visual Studio Solution File, Format Version 12.00\n# Visual Studio Version 16\nVisualStudioVersion = 16.0.2912"
},
{
"path": "build.gradle.kts",
"chars": 19546,
"preview": "import com.jetbrains.plugin.structure.base.utils.isFile\nimport org.apache.tools.ant.taskdefs.condition.Os\nimport org.gra"
},
{
"path": "gradle/wrapper/gradle-wrapper.properties",
"chars": 283,
"preview": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://cache-redirector.jetbrains.com"
},
{
"path": "gradle.properties",
"chars": 1049,
"preview": "# Properties for the build. Override on the command line with -Pprop=value\n# E.g. -PBuildConfiguration=Release\n# Note th"
},
{
"path": "gradlew",
"chars": 11587,
"preview": "#!/bin/sh\n\n#\n# Copyright © 2015 the original authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")"
},
{
"path": "gradlew.bat",
"chars": 5521,
"preview": "@rem\r\n@rem Copyright 2015 the original author or authors.\r\n@rem\r\n@rem Licensed under the Apache License, Version 2.0 (th"
},
{
"path": "protocol/build.gradle.kts",
"chars": 5760,
"preview": "import com.jetbrains.rd.generator.gradle.RdGenTask\n\nplugins {\n // Version is configured in gradle.properties\n id(\""
},
{
"path": "protocol/src/main/kotlin/model/editorPlugin/LiveCodingModel.kt",
"chars": 692,
"preview": "package model.editorPlugin\n\nimport com.jetbrains.rd.generator.nova.*\nimport com.jetbrains.rd.generator.nova.PredefinedTy"
},
{
"path": "protocol/src/main/kotlin/model/editorPlugin/RdEditorModel.kt",
"chars": 2144,
"preview": "package model.editorPlugin\n\nimport com.jetbrains.rd.generator.nova.*\nimport com.jetbrains.rd.generator.nova.PredefinedTy"
},
{
"path": "protocol/src/main/kotlin/model/lib/ue4/UE4Library.kt",
"chars": 7436,
"preview": "package model.lib.ue4\n\nimport com.jetbrains.rd.generator.nova.*\nimport com.jetbrains.rd.generator.nova.PredefinedType.*\n"
},
{
"path": "protocol/src/main/kotlin/model/rider/RdRiderModel.kt",
"chars": 5009,
"preview": "package model.rider\n\nimport com.jetbrains.rd.generator.nova.*\nimport com.jetbrains.rd.generator.nova.PredefinedType.*\nim"
},
{
"path": "settings.gradle.kts",
"chars": 1301,
"preview": "rootProject.name = \"UnrealLink\"\n\npluginManagement {\n val rdVersion: String by settings\n val rdKotlinVersion: Strin"
},
{
"path": "setup_unreal_plugin.cmd",
"chars": 41,
"preview": ".\\gradlew -q symlinkPluginToUnrealProject"
},
{
"path": "src/SubplatformsCollection.Root",
"chars": 0,
"preview": ""
},
{
"path": "src/cpp/BuildScript/GenerateRiderLinkZip.cs",
"chars": 3027,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Collections.Immutable;\nusing System.Linq;\nusing System.Secu"
},
{
"path": "src/cpp/RiderLink/RiderLink.uplugin.template",
"chars": 1363,
"preview": "{\n\t\"FileVersion\": 3,\n\t\"Version\": 1,\n\t\"VersionName\": \"%PLUGIN_VERSION%\",\n\t\"FriendlyName\": \"RiderLink\",\n\t\"Description\": \"P"
},
{
"path": "src/cpp/RiderLink/Source/RD/RD.Build.cs",
"chars": 2597,
"preview": "using System.IO;\nusing UnrealBuildTool;\n\npublic class RD : ModuleRules\n{\n\tpublic RD(ReadOnlyTargetRules Target) : base(T"
},
{
"path": "src/cpp/RiderLink/Source/RD/RD.cpp",
"chars": 179,
"preview": "#include \"RD.h\"\n\n#include <Modules/ModuleManager.h>\n\n#define LOCTEXT_NAMESPACE \"RD\"\n\nDEFINE_LOG_CATEGORY(FLogRDModule);\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/RD.h",
"chars": 337,
"preview": "// Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.\n\n#pragma once\n\n#include \"Logging/LogMacros.h\"\n#include \"Log"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/rd_core_export.h",
"chars": 1981,
"preview": "\n#ifndef RD_CORE_API_H\n#define RD_CORE_API_H\n\n#if defined(_WIN32)\n#ifdef RD_CORE_STATIC_DEFINE\n# define RD_CORE_API\n# "
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/Lifetime.cpp",
"chars": 988,
"preview": "#include \"Lifetime.h\"\n\n#include <memory>\n\n#include <thirdparty.hpp>\n#include <spdlog/spdlog.h>\n#include <spdlog/sinks/st"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/Lifetime.h",
"chars": 1493,
"preview": "#ifndef RD_CPP_CORE_LIFETIMEWRAPPER_H\n#define RD_CPP_CORE_LIFETIMEWRAPPER_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeDefinition.cpp",
"chars": 988,
"preview": "#include \"LifetimeDefinition.h\"\n\n#include <spdlog/spdlog.h>\n\nnamespace rd\n{\nLifetimeDefinition::LifetimeDefinition(bool "
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeDefinition.h",
"chars": 1293,
"preview": "#ifndef RD_CPP_CORE_LIFETIME_DEFINITION_H\n#define RD_CPP_CORE_LIFETIME_DEFINITION_H\n\n#include \"util/core_traits.h\"\n\n#inc"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeImpl.cpp",
"chars": 1260,
"preview": "#include \"LifetimeImpl.h\"\n\n#include <utility>\n\nnamespace rd\n{\n#if __cplusplus < 201703L\nLifetimeImpl::counter_t Lifetime"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/LifetimeImpl.h",
"chars": 1880,
"preview": "#ifndef RD_CPP_CORE_LIFETIME_H\n#define RD_CPP_CORE_LIFETIME_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warni"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/SequentialLifetimes.cpp",
"chars": 938,
"preview": "#include \"SequentialLifetimes.h\"\n\nnamespace rd\n{\nSequentialLifetimes::SequentialLifetimes(Lifetime parent_lifetime) : pa"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/lifetime/SequentialLifetimes.h",
"chars": 1096,
"preview": "#ifndef RD_CPP_CORE_SEQUENTIAL_LIFETIMES_H\n#define RD_CPP_CORE_SEQUENTIAL_LIFETIMES_H\n\n#if defined(_MSC_VER)\n#pragma war"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/Property.h",
"chars": 1624,
"preview": "#ifndef RD_CPP_CORE_PROPERTY_H\n#define RD_CPP_CORE_PROPERTY_H\n\n#include \"base/IProperty.h\"\n#include \"reactive/base/Signa"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableList.h",
"chars": 6593,
"preview": "#ifndef RD_CPP_CORE_VIEWABLELIST_H\n#define RD_CPP_CORE_VIEWABLELIST_H\n\n#include \"base/IViewableList.h\"\n#include \"reactiv"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableMap.h",
"chars": 6977,
"preview": "#ifndef RD_CPP_CORE_VIEWABLE_MAP_H\n#define RD_CPP_CORE_VIEWABLE_MAP_H\n\n#include \"base/IViewableMap.h\"\n#include \"reactive"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/ViewableSet.h",
"chars": 5124,
"preview": "#ifndef RD_CPP_CORE_VIEWABLESET_H\n#define RD_CPP_CORE_VIEWABLESET_H\n\n#include \"base/IViewableSet.h\"\n#include \"reactive/b"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IProperty.h",
"chars": 1870,
"preview": "#ifndef RD_CPP_IPROPERTY_H\n#define RD_CPP_IPROPERTY_H\n\n#include \"SignalX.h\"\n#include \"IPropertyBase.h\"\n\n#include <lifeti"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IPropertyBase.h",
"chars": 1486,
"preview": "#ifndef RD_CPP_IPROPERTYBASE_H\n#define RD_CPP_IPROPERTYBASE_H\n\n#include \"interfaces.h\"\n#include \"SignalX.h\"\n\n#include <t"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableList.h",
"chars": 6748,
"preview": "#ifndef RD_CPP_IVIEWABLELIST_H\n#define RD_CPP_IVIEWABLELIST_H\n\n#include \"interfaces.h\"\n#include \"viewable_collections.h\""
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableMap.h",
"chars": 7059,
"preview": "#ifndef RD_CPP_IVIEWABLEMAP_H\n#define RD_CPP_IVIEWABLEMAP_H\n\n#include \"lifetime/LifetimeDefinition.h\"\n#include \"util/ove"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/IViewableSet.h",
"chars": 4182,
"preview": "#ifndef RD_CPP_IVIEWABLESET_H\n#define RD_CPP_IVIEWABLESET_H\n\n#include \"interfaces.h\"\n#include \"viewable_collections.h\"\n\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/SignalCookie.cpp",
"chars": 229,
"preview": "#include \"SignalCookie.h\"\n\n#include <atomic>\n\nnamespace\n{\nstd::atomic<int32_t> cookie;\n}\n\nvoid rd_signal_cookie_inc()\n{\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/SignalCookie.h",
"chars": 303,
"preview": "#ifndef RD_CPP_SIGNALCOOKIE_H\n#define RD_CPP_SIGNALCOOKIE_H\n\n#include <cstdint>\n#include <rd_core_export.h>\n\nextern \"C\" "
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/SignalX.h",
"chars": 2775,
"preview": "#ifndef RD_CPP_CORE_SIGNAL_H\n#define RD_CPP_CORE_SIGNAL_H\n\n#include \"interfaces.h\"\n#include \"SignalCookie.h\"\n\n#include <"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/interfaces.h",
"chars": 1935,
"preview": "#ifndef RD_CPP_CORE_INTERFACES_H\n#define RD_CPP_CORE_INTERFACES_H\n\n#include <lifetime/Lifetime.h>\n#include <types/wrappe"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/reactive/base/viewable_collections.h",
"chars": 673,
"preview": "#ifndef RD_CPP_VIEWABLE_COLLECTIONS_H\n#define RD_CPP_VIEWABLE_COLLECTIONS_H\n\n#include <string>\n\nnamespace rd\n{\nenum clas"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/allocator.h",
"chars": 182,
"preview": "#ifndef RD_CPP_ALLOCATOR_H\n#define RD_CPP_ALLOCATOR_H\n\n#include <memory>\n\nnamespace rd\n{\ntemplate <typename T>\nusing all"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/hash.h",
"chars": 275,
"preview": "#ifndef RD_CPP_HASH_H\n#define RD_CPP_HASH_H\n\n#include <cstddef>\n#include <functional>\n\nnamespace rd\n{\ntemplate <typename"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/list.h",
"chars": 634,
"preview": "#ifndef RD_CPP_LIST_H\n#define RD_CPP_LIST_H\n\n#include <vector>\n#include <cstdint>\n\nnamespace rd\n{\ntemplate <typename T>\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/to_string.h",
"chars": 2680,
"preview": "// ReSharper disable CppUE4CodingStandardNamingViolationWarning\n#ifndef RD_CPP_TO_STRING_H\n#define RD_CPP_TO_STRING_H\n\n#"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/unordered_map.h",
"chars": 392,
"preview": "#ifndef RD_CPP_UNORDERED_MAP_H\n#define RD_CPP_UNORDERED_MAP_H\n\n#include \"hash.h\"\n\n#include <unordered_map>\n\nnamespace rd"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/std/unordered_set.h",
"chars": 362,
"preview": "#ifndef RD_CPP_UNORDERED_SET_H\n#define RD_CPP_UNORDERED_SET_H\n\n#include \"hash.h\"\n\n#include <unordered_set>\n\nnamespace rd"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/DateTime.cpp",
"chars": 984,
"preview": "#include \"DateTime.h\"\n\n#include <sstream>\n#include <iomanip>\n\nnamespace rd\n{\nDateTime::DateTime(time_t seconds) : second"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/DateTime.h",
"chars": 1136,
"preview": "#ifndef RD_CPP_DATETIME_H\n#define RD_CPP_DATETIME_H\n\n#include <std/hash.h>\n\n#include <ctime>\n#include <string>\n\n#include"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/Void.h",
"chars": 572,
"preview": "#ifndef RD_CPP_VOID_H\n#define RD_CPP_VOID_H\n\n#include <functional>\n#include <string>\n\nnamespace rd\n{\n/**\n * \\brief For u"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/types/wrapper.h",
"chars": 6652,
"preview": "#ifndef RD_CPP_WRAPPER_H\n#define RD_CPP_WRAPPER_H\n\n#include <util/core_traits.h>\n#include <std/allocator.h>\n#include <st"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/core_traits.h",
"chars": 3924,
"preview": "#ifndef RD_CORE_CPP_TRAITS_H\n#define RD_CORE_CPP_TRAITS_H\n\n#include <types/Void.h>\n\n#include <type_traits>\n#include <str"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/core_util.h",
"chars": 2167,
"preview": "#ifndef RD_CPP_CORE_CPP_UTIL_H\n#define RD_CPP_CORE_CPP_UTIL_H\n\n#include \"erase_if.h\"\n#include \"gen_util.h\"\n#include \"ove"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/enum.h",
"chars": 3562,
"preview": "#ifndef RD_CPP_ENUM_H\n#define RD_CPP_ENUM_H\n\n#include <type_traits>\n\n#define RD_DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) "
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/erase_if.h",
"chars": 369,
"preview": "#ifndef RD_CPP_ERASE_IF_H\n#define RD_CPP_ERASE_IF_H\n\nnamespace rd\n{\nnamespace util\n{\ntemplate <typename ContainerT, clas"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/gen_util.h",
"chars": 1672,
"preview": "#ifndef RD_CPP_GEN_UTIL_H\n#define RD_CPP_GEN_UTIL_H\n\n#include <std/hash.h>\n#include <std/allocator.h>\n\n#include <cstdlib"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/overloaded.h",
"chars": 652,
"preview": "#ifndef RD_CPP_OVERLOADED_H\n#define RD_CPP_OVERLOADED_H\n\nnamespace rd\n{\nnamespace util\n{\ntemplate <typename... Ts>\nstruc"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_core_cpp/src/main/util/shared_function.h",
"chars": 855,
"preview": "#ifndef RD_CPP_SHARED_FUNCTION_H\n#define RD_CPP_SHARED_FUNCTION_H\n\n#include <memory>\n\nnamespace rd\n{\nnamespace util\n{\nte"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/rd_framework_export.h",
"chars": 2228,
"preview": "\n#ifndef RD_FRAMEWORK_API_H\n#define RD_FRAMEWORK_API_H\n\n#if defined(_WIN32)\n# ifdef RD_FRAMEWORK_STATIC_DEFINE\n# define"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IProtocol.cpp",
"chars": 937,
"preview": "#include \"IProtocol.h\"\n\n#include \"scheduler/base/IScheduler.h\"\n#include \"protocol/Identities.h\"\n#include \"base/IWire.h\"\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IProtocol.h",
"chars": 1527,
"preview": "#ifndef RD_CPP_IPROTOCOL_H\n#define RD_CPP_IPROTOCOL_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(disab"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdBindable.h",
"chars": 2766,
"preview": "#ifndef RD_CPP_FRAMEWORK_IRDBINDABLE_H\n#define RD_CPP_FRAMEWORK_IRDBINDABLE_H\n\n#include \"IRdDynamic.h\"\n#include \"lifetim"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdDynamic.h",
"chars": 810,
"preview": "#ifndef RD_CPP_IRDDYNAMIC_H\n#define RD_CPP_IRDDYNAMIC_H\n\n#include \"impl/RName.h\"\n\n#include <rd_framework_export.h>\n\nname"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdReactive.h",
"chars": 1184,
"preview": "#ifndef RD_CPP_FRAMEWORK_IRDREACTIVE_H\n#define RD_CPP_FRAMEWORK_IRDREACTIVE_H\n\n#include \"IRdBindable.h\"\n#include \"schedu"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdWireable.cpp",
"chars": 42,
"preview": "#include \"IRdWireable.h\"\n\nnamespace rd\n{\n}"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IRdWireable.h",
"chars": 340,
"preview": "#ifndef RD_CPP_IRDWIREABLE_H\n#define RD_CPP_IRDWIREABLE_H\n\n#include \"protocol/RdId.h\"\n#include \"scheduler/base/ISchedule"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/ISerializersOwner.cpp",
"chars": 252,
"preview": "#include \"ISerializersOwner.h\"\n\nnamespace rd\n{\nvoid ISerializersOwner::registry(Serializers const& serializers) const\n{\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/ISerializersOwner.h",
"chars": 717,
"preview": "#ifndef RD_CPP_ISERIALIZERSOWNER_H\n#define RD_CPP_ISERIALIZERSOWNER_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#prag"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IUnknownInstance.cpp",
"chars": 284,
"preview": "#include \"IUnknownInstance.h\"\n\nnamespace rd\n{\nIUnknownInstance::IUnknownInstance()\n{\n}\n\nIUnknownInstance::IUnknownInstan"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IUnknownInstance.h",
"chars": 398,
"preview": "#ifndef RD_CPP_IUNKNOWNINSTANCE_H\n#define RD_CPP_IUNKNOWNINSTANCE_H\n\n#include \"protocol/RdId.h\"\n\n#include <rd_framework_"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/IWire.h",
"chars": 1355,
"preview": "#ifndef RD_CPP_IWIRE_H\n#define RD_CPP_IWIRE_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(disable:4251)"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdBindableBase.cpp",
"chars": 2229,
"preview": "#include \"RdBindableBase.h\"\n\n#include \"reactive/base/SignalX.h\"\n\nnamespace rd\n{\nstd::string RdBindableBase::toString() c"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdBindableBase.h",
"chars": 3397,
"preview": "#ifndef RD_CPP_RDBINDABLEBASE_H\n#define RD_CPP_RDBINDABLEBASE_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma war"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdPropertyBase.h",
"chars": 3603,
"preview": "#ifndef RD_CPP_RDPROPERTYBASE_H\n#define RD_CPP_RDPROPERTYBASE_H\n\n#include \"base/RdReactiveBase.h\"\n#include \"serializatio"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdReactiveBase.cpp",
"chars": 1330,
"preview": "#include \"RdReactiveBase.h\"\n\n#include \"spdlog/sinks/stdout_color_sinks.h\"\n\nnamespace rd\n{\nstatic std::shared_ptr<spdlog:"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/RdReactiveBase.h",
"chars": 1420,
"preview": "#ifndef RD_CPP_RDREACTIVEBASE_H\n#define RD_CPP_RDREACTIVEBASE_H\n\n#include \"base/RdBindableBase.h\"\n#include \"base/IRdReac"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/WireBase.cpp",
"chars": 183,
"preview": "#include \"WireBase.h\"\n\nnamespace rd\n{\nvoid WireBase::advise(Lifetime lifetime, const RdReactiveBase* entity) const\n{\n\tme"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/base/WireBase.h",
"chars": 635,
"preview": "#ifndef RD_CPP_WIREBASE_H\n#define RD_CPP_WIREBASE_H\n\n#include \"reactive/Property.h\"\n#include \"base/IWire.h\"\n#include \"pr"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/ext/ExtWire.cpp",
"chars": 1014,
"preview": "#include \"ExtWire.h\"\n\n#include \"protocol/Buffer.h\"\n\nnamespace rd\n{\nExtWire::ExtWire()\n{\n\tconnected.advise(Lifetime::Eter"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/ext/ExtWire.h",
"chars": 799,
"preview": "#ifndef RD_CPP_EXTWIRE_H\n#define RD_CPP_EXTWIRE_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(disable:4"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/ext/RdExtBase.cpp",
"chars": 3194,
"preview": "#include \"RdExtBase.h\"\n\n#include \"lifetime/Lifetime.h\"\n#include \"base/RdPropertyBase.h\"\n#include \"protocol/Protocol.h\"\n#"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/ext/RdExtBase.h",
"chars": 1384,
"preview": "#ifndef RD_CPP_RDEXTBASE_H\n#define RD_CPP_RDEXTBASE_H\n\n#include \"base/RdReactiveBase.h\"\n#include \"ExtWire.h\"\n\n#include \""
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RName.cpp",
"chars": 1390,
"preview": "#include \"RName.h\"\n\n#include \"thirdparty.hpp\"\n\nnamespace rd\n{\nclass RNameImpl\n{\npublic:\n\t// region ctor/dtor\n\tRNameImpl("
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RName.h",
"chars": 1075,
"preview": "#ifndef RD_CPP_FRAMEWORK_RNAME_H\n#define RD_CPP_FRAMEWORK_RNAME_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma w"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdList.h",
"chars": 6769,
"preview": "#ifndef RD_CPP_RDLIST_H\n#define RD_CPP_RDLIST_H\n\n#include \"reactive/ViewableList.h\"\n#include \"base/RdReactiveBase.h\"\n#in"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdMap.h",
"chars": 8213,
"preview": "#ifndef RD_CPP_RDMAP_H\n#define RD_CPP_RDMAP_H\n\n#include \"reactive/ViewableMap.h\"\n#include \"base/RdReactiveBase.h\"\n#inclu"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdProperty.h",
"chars": 2531,
"preview": "#ifndef RD_CPP_RDPROPERTY_H\n#define RD_CPP_RDPROPERTY_H\n\n#include \"base/RdPropertyBase.h\"\n#include \"serialization/Polymo"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdSet.h",
"chars": 3567,
"preview": "#ifndef RD_CPP_RDSET_H\n#define RD_CPP_RDSET_H\n\n#include \"reactive/ViewableSet.h\"\n#include \"base/RdReactiveBase.h\"\n#inclu"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/impl/RdSignal.h",
"chars": 3407,
"preview": "#ifndef RD_CPP_RDSIGNAL_H\n#define RD_CPP_RDSIGNAL_H\n\n#include \"lifetime/Lifetime.h\"\n#include \"reactive/base/interfaces.h"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/intern/InternRoot.cpp",
"chars": 1946,
"preview": "#include \"InternRoot.h\"\n\n#include \"serialization/AbstractPolymorphic.h\"\n#include \"serialization/InternedAnySerializer.h\""
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/intern/InternRoot.h",
"chars": 3242,
"preview": "#ifndef RD_CPP_INTERNROOT_H\n#define RD_CPP_INTERNROOT_H\n\n#include \"base/RdReactiveBase.h\"\n#include \"InternScheduler.h\"\n#"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/intern/InternScheduler.cpp",
"chars": 449,
"preview": "#include \"InternScheduler.h\"\n\n#include \"guards.h\"\n\nnamespace rd\n{\nthread_local int32_t InternScheduler::active_counts = "
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/intern/InternScheduler.h",
"chars": 566,
"preview": "#ifndef RD_CPP_INTERNSCHEDULER_H\n#define RD_CPP_INTERNSCHEDULER_H\n\n#include \"scheduler/base/IScheduler.h\"\n\n#include <rd_"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Buffer.cpp",
"chars": 5399,
"preview": "#include <utility>\n\n#include \"protocol/Buffer.h\"\n\n#include <string>\n#include <algorithm>\n\nnamespace rd\n{\nBuffer::Buffer("
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Buffer.h",
"chars": 7362,
"preview": "#ifndef RD_CPP_UNSAFEBUFFER_H\n#define RD_CPP_UNSAFEBUFFER_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Identities.cpp",
"chars": 405,
"preview": "#include \"protocol/Identities.h\"\n\nnamespace rd\n{\nconstexpr Identities::IdKind Identities::SERVER;\nconstexpr Identities::"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Identities.h",
"chars": 1124,
"preview": "#ifndef RD_CPP_FRAMEWORK_IDENTITIES_H\n#define RD_CPP_FRAMEWORK_IDENTITIES_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/MessageBroker.cpp",
"chars": 3843,
"preview": "#include \"protocol/MessageBroker.h\"\n\n#include \"base/RdReactiveBase.h\"\n#include \"spdlog/sinks/stdout_color_sinks.h\"\n\nname"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/MessageBroker.h",
"chars": 1350,
"preview": "#ifndef RD_CPP_MESSAGEBROKER_H\n#define RD_CPP_MESSAGEBROKER_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warni"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Protocol.cpp",
"chars": 1442,
"preview": "#include \"protocol/Protocol.h\"\n\n#include \"serialization/SerializationCtx.h\"\n#include \"intern/InternRoot.h\"\n\n#include \"sp"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/Protocol.h",
"chars": 1451,
"preview": "#ifndef RD_CPP_PROTOCOL_H\n#define RD_CPP_PROTOCOL_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(disable"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/RdId.cpp",
"chars": 526,
"preview": "#include \"protocol/RdId.h\"\n\n#include \"protocol/Identities.h\"\n\nnamespace rd\n{\nRdId RdId::read(Buffer& buffer)\n{\n\tconst au"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/protocol/RdId.h",
"chars": 2443,
"preview": "#ifndef RD_CPP_FRAMEWORK_RDID_H\n#define RD_CPP_FRAMEWORK_RDID_H\n\n#include \"protocol/Buffer.h\"\n#include \"hashing.h\"\n#incl"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SimpleScheduler.cpp",
"chars": 230,
"preview": "#include \"SimpleScheduler.h\"\n\nnamespace rd\n{\nvoid SimpleScheduler::flush()\n{\n}\n\nvoid SimpleScheduler::queue(std::functio"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SimpleScheduler.h",
"chars": 597,
"preview": "#ifndef RD_CPP_TESTSCHEDULER_H\n#define RD_CPP_TESTSCHEDULER_H\n\n#include \"scheduler/base/IScheduler.h\"\n\n#include <rd_fram"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SingleThreadScheduler.cpp",
"chars": 444,
"preview": "#include \"SingleThreadScheduler.h\"\n\n#include <utility>\n\n#include \"ctpl_stl.h\"\n\nnamespace rd\n{\nSingleThreadScheduler::Sin"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SingleThreadScheduler.h",
"chars": 443,
"preview": "#ifndef RD_CPP_SINGLETHREADSCHEDULER_H\n#define RD_CPP_SINGLETHREADSCHEDULER_H\n\n#include \"base/SingleThreadSchedulerBase."
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SynchronousScheduler.cpp",
"chars": 599,
"preview": "#include \"SynchronousScheduler.h\"\n\n#include \"guards.h\"\n\nnamespace rd\n{\nstatic thread_local int32_t SynchronousScheduler_"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/SynchronousScheduler.h",
"chars": 791,
"preview": "#ifndef RD_CPP_SYNCHRONOUSSCHEDULER_H\n#define RD_CPP_SYNCHRONOUSSCHEDULER_H\n\n#include \"scheduler/base/IScheduler.h\"\n\n#in"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/base/IScheduler.cpp",
"chars": 498,
"preview": "#include \"IScheduler.h\"\n\n#include \"spdlog/spdlog.h\"\n\n#include <functional>\n#include <sstream>\n\nnamespace rd\n{\nvoid ISche"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/base/IScheduler.h",
"chars": 1158,
"preview": "#ifndef RD_CPP_ISCHEDULER_H\n#define RD_CPP_ISCHEDULER_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(dis"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/base/SingleThreadSchedulerBase.cpp",
"chars": 1574,
"preview": "#include \"SingleThreadSchedulerBase.h\"\n\n#include \"util/core_util.h\"\n\n#include \"ctpl_stl.h\"\n#include \"spdlog/include/spdl"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/scheduler/base/SingleThreadSchedulerBase.h",
"chars": 1215,
"preview": "#ifndef RD_CPP_SINGLETHREADSCHEDULERBASE_H\n#define RD_CPP_SINGLETHREADSCHEDULERBASE_H\n\n#if defined(_MSC_VER)\n#pragma war"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/AbstractPolymorphic.h",
"chars": 785,
"preview": "#ifndef RD_CPP_ABSTRACTPOLYMORPHIC_H\n#define RD_CPP_ABSTRACTPOLYMORPHIC_H\n\n#include \"types/wrapper.h\"\n#include \"serializ"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/ArraySerializer.h",
"chars": 777,
"preview": "#ifndef RD_CPP_ARRAYSERIALIZER_H\n#define RD_CPP_ARRAYSERIALIZER_H\n\n#include \"serialization/SerializationCtx.h\"\n#include "
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/DefaultAbstractDeclaration.cpp",
"chars": 1023,
"preview": "#include \"DefaultAbstractDeclaration.h\"\n\nnamespace rd\n{\nconst std::string DefaultAbstractDeclaration::not_registered_err"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/DefaultAbstractDeclaration.h",
"chars": 860,
"preview": "#ifndef RD_CPP_DEFAULTABSTRACTDECLARATION_H\n#define RD_CPP_DEFAULTABSTRACTDECLARATION_H\n\n#include \"types/wrapper.h\"\n#inc"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/ISerializable.cpp",
"chars": 465,
"preview": "#include \"serialization/ISerializable.h\"\n\n#include \"std/hash.h\"\n\nnamespace rd\n{\nsize_t IPolymorphicSerializable::hashCod"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/ISerializable.h",
"chars": 1606,
"preview": "#ifndef RD_CPP_ISERIALIZABLE_H\n#define RD_CPP_ISERIALIZABLE_H\n\n#include <string>\n\n#include <rd_framework_export.h>\n\nname"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/InternedAnySerializer.h",
"chars": 637,
"preview": "#ifndef RD_CPP_ANYSERIALIZER_H\n#define RD_CPP_ANYSERIALIZER_H\n\n#include \"serialization/SerializationCtx.h\"\n#include \"ser"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/InternedSerializer.h",
"chars": 822,
"preview": "#ifndef RD_CPP_INTERNEDSERIALIZER_H\n#define RD_CPP_INTERNEDSERIALIZER_H\n\n#include \"serialization/SerializationCtx.h\"\n#in"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/NullableSerializer.h",
"chars": 1502,
"preview": "#ifndef RD_CPP_NULLABLESERIALIZER_H\n#define RD_CPP_NULLABLESERIALIZER_H\n\n#include \"serialization/Polymorphic.h\"\n#include"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/Polymorphic.cpp",
"chars": 60,
"preview": "#include \"Polymorphic.h\"\n\nnamespace rd\n{\n}\t // namespace rd\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/Polymorphic.h",
"chars": 5017,
"preview": "#ifndef RD_CPP_POLYMORPHIC_H\n#define RD_CPP_POLYMORPHIC_H\n\n#include \"protocol/Buffer.h\"\n#include \"base/RdReactiveBase.h\""
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/RdAny.cpp",
"chars": 71,
"preview": "#include \"RdAny.h\"\n\nnamespace rd\n{\nnamespace any\n{\n}\n}\t // namespace rd"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/RdAny.h",
"chars": 3411,
"preview": "#ifndef RD_CPP_ANY_H\n#define RD_CPP_ANY_H\n\n#include \"util/core_util.h\"\n#include \"types/wrapper.h\"\n#include \"serializatio"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/SerializationCtx.cpp",
"chars": 1050,
"preview": "#include \"SerializationCtx.h\"\n\nnamespace rd\n{\n//\tSerializationCtx::SerializationCtx(const IProtocol &protocol) : seriali"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/SerializationCtx.h",
"chars": 2809,
"preview": "#ifndef RD_CPP_FRAMEWORK_SERIALIZATIONCTX_H\n#define RD_CPP_FRAMEWORK_SERIALIZATIONCTX_H\n\n#if defined(_MSC_VER)\n#pragma w"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/Serializers.cpp",
"chars": 1190,
"preview": "#include \"Serializers.h\"\n\n#include \"serialization/AbstractPolymorphic.h\"\n\nnamespace rd\n{\nconstexpr RdId STRING_PREDEFINE"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/serialization/Serializers.h",
"chars": 4701,
"preview": "#ifndef RD_CPP_SERIALIZERS_H\n#define RD_CPP_SERIALIZERS_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(d"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdCall.h",
"chars": 4340,
"preview": "#ifndef RD_CPP_RDCALL_H\n#define RD_CPP_RDCALL_H\n\n#include \"serialization/Polymorphic.h\"\n#include \"RdTask.h\"\n#include \"Rd"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdEndpoint.h",
"chars": 3681,
"preview": "#ifndef RD_CPP_RDENDPOINT_H\n#define RD_CPP_RDENDPOINT_H\n\n#include \"serialization/Polymorphic.h\"\n#include \"RdTask.h\"\n\n#if"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdSymmetricCall.h",
"chars": 989,
"preview": "#ifndef RD_CPP_RDSYMMETRICCALL_H\n#define RD_CPP_RDSYMMETRICCALL_H\n\n#include \"task/RdCall.h\"\n#include \"task/RdEndpoint.h\""
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdTask.h",
"chars": 2381,
"preview": "#ifndef RD_CPP_RDTASK_H\n#define RD_CPP_RDTASK_H\n\n#include \"RdTaskImpl.h\"\n#include \"serialization/Polymorphic.h\"\n\n#includ"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdTaskImpl.h",
"chars": 500,
"preview": "#ifndef RD_CPP_RDTASKIMPL_H\n#define RD_CPP_RDTASKIMPL_H\n\n#include \"serialization/Polymorphic.h\"\n#include \"RdTaskResult.h"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/RdTaskResult.h",
"chars": 4270,
"preview": "#ifndef RD_CPP_RDTASKRESULT_H\n#define RD_CPP_RDTASKRESULT_H\n\n#include \"serialization/Polymorphic.h\"\n#include \"util/overl"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/WiredRdTask.h",
"chars": 950,
"preview": "#ifndef RD_CPP_WIREDRDTASK_H\n#define RD_CPP_WIREDRDTASK_H\n\n#include \"RdTask.h\"\n#include \"WiredRdTaskImpl.h\"\n#include \"ba"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/task/WiredRdTaskImpl.h",
"chars": 1995,
"preview": "#ifndef RD_CPP_WIREDRDTASKIMPL_H\n#define RD_CPP_WIREDRDTASKIMPL_H\n\n#include \"serialization/Polymorphic.h\"\n#include \"RdTa"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/framework_traits.h",
"chars": 492,
"preview": "#ifndef RD_CPP_FRAMEWORK_TRAITS_H\n#define RD_CPP_FRAMEWORK_TRAITS_H\n\n#include \"serialization/Polymorphic.h\"\n\n#include <u"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/guards.h",
"chars": 449,
"preview": "#ifndef RD_CPP_GUARDS_H\n#define RD_CPP_GUARDS_H\n\nnamespace rd\n{\nnamespace util\n{\ntemplate <typename T>\nclass increment_g"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/hashing.cpp",
"chars": 0,
"preview": ""
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/hashing.h",
"chars": 1471,
"preview": "#ifndef RD_CPP_HASHING_H\n#define RD_CPP_HASHING_H\n\n#include \"nonstd/string_view.hpp\"\n\n#include <cstdint>\n#include <cstdl"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/thread_util.cpp",
"chars": 1250,
"preview": "#include \"thread_util.h\"\n\n#ifdef _WIN32\n\n#include <windows.h>\nconst DWORD MS_VC_EXCEPTION = 0x406D1388;\n\n#pragma pack(pu"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/util/thread_util.h",
"chars": 207,
"preview": "#ifndef RD_CPP_THREAD_UTIL_H\n#define RD_CPP_THREAD_UTIL_H\n\n#include <thread>\n\nnamespace rd\n{\nnamespace util\n{\nvoid set_t"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/ByteBufferAsyncProcessor.cpp",
"chars": 6697,
"preview": "#include \"ByteBufferAsyncProcessor.h\"\n\n#include \"util/guards.h\"\n#include <util/thread_util.h>\n\n#include \"spdlog/sinks/st"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/ByteBufferAsyncProcessor.h",
"chars": 2279,
"preview": "#ifndef RD_CPP_BYTEBUFFERASYNCPROCESSOR_H\n#define RD_CPP_BYTEBUFFERASYNCPROCESSOR_H\n\n#if defined(_MSC_VER)\n#pragma warni"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/PkgInputStream.cpp",
"chars": 1294,
"preview": "#define NOMINMAX\n\n#include \"PkgInputStream.h\"\n\n#include <algorithm>\n\nnamespace rd\n{\nvoid PkgInputStream::rewind()\n{\n\tbuf"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/PkgInputStream.h",
"chars": 958,
"preview": "#ifndef RD_CPP_PKGINPUTSTREAM_H\n#define RD_CPP_PKGINPUTSTREAM_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma war"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/PumpScheduler.cpp",
"chars": 1126,
"preview": "#include \"wire/PumpScheduler.h\"\n\n#include \"util/core_util.h\"\n\nnamespace rd\n{\nnamespace test\n{\nnamespace util\n{\nPumpSched"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/PumpScheduler.h",
"chars": 1049,
"preview": "#ifndef RD_CPP_PUMPSCHEDULER_H\n#define RD_CPP_PUMPSCHEDULER_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warni"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/SocketWire.cpp",
"chars": 19200,
"preview": "#include \"wire/SocketWire.h\"\n\n#include <util/thread_util.h>\n\n#include \"spdlog/sinks/stdout_color_sinks.h\"\n\n#include <Sim"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/SocketWire.h",
"chars": 4782,
"preview": "#ifndef RD_CPP_SOCKETWIRE_H\n#define RD_CPP_SOCKETWIRE_H\n\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(dis"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/WireUtil.cpp",
"chars": 540,
"preview": "#include \"wire/WireUtil.h\"\n\n#include \"util/core_util.h\"\n\n#include \"PassiveSocket.h\"\n#include \"Host.h\"\n\n#include <utility"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_framework_cpp/src/main/wire/WireUtil.h",
"chars": 308,
"preview": "#ifndef RD_CPP_WIREUTIL_H\n#define RD_CPP_WIREUTIL_H\n\n#include <cstdint>\n\n#include <rd_framework_export.h>\n\nnamespace rd\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_gen_cpp/src/RdTextBuffer.cpp",
"chars": 26,
"preview": "#include \"RdTextBuffer.h\"\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/src/rd_gen_cpp/src/RdTextBuffer.h",
"chars": 154,
"preview": "#ifndef RD_CPP_RDTEXTBUFFER_H\n#define RD_CPP_RDTEXTBUFFER_H\n\nnamespace rd\n{\nclass RdTextBuffer\n{\n};\n}\t // namespace rd\n\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/CTPL/LICENSE",
"chars": 10737,
"preview": "Apache License\n Version 2.0, January 2004\n http://www.apache.org/licens"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/CTPL/README.md",
"chars": 2467,
"preview": "CTPL\n====\n\nModern and efficient C++ Thread Pool Library\n\n\nA thread pool is a programming pattern for parallel execution "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/CTPL/include/ctpl_stl.h",
"chars": 10061,
"preview": "/*********************************************************\n*\n* Copyright (C) 2014 by Vitaliy Vitsentiy\n*\n* Licensed un"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/README",
"chars": 7567,
"preview": "------------------------------------------------------------------------------------------\n* History\n-------------------"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/ActiveSocket.cpp",
"chars": 10419,
"preview": "/*---------------------------------------------------------------------------*/\n/* "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/ActiveSocket.h",
"chars": 4329,
"preview": "/*---------------------------------------------------------------------------*/\n/* "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/Host.h",
"chars": 8624,
"preview": "/*---------------------------------------------------------------------------*/\n/* "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/PassiveSocket.cpp",
"chars": 11980,
"preview": "/*---------------------------------------------------------------------------*/\n/* "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/PassiveSocket.h",
"chars": 6794,
"preview": "/*---------------------------------------------------------------------------*/\n/* "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/SimpleSocket.cpp",
"chars": 37200,
"preview": "/*---------------------------------------------------------------------------*/\n/* "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/SimpleSocket.h",
"chars": 26601,
"preview": "/*---------------------------------------------------------------------------*/\n/* "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/clsocket/src/StatTimer.h",
"chars": 4224,
"preview": "/*----------------------------------------------------------------------------*/\n/* "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/countdownlatch/LICENSE",
"chars": 1081,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2016 Nipun Talukdar\n\nPermission is hereby granted, free of charge, to any person ob"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/countdownlatch/README.md",
"chars": 1140,
"preview": "CountdownLatch for C++ multi-threaded programming\n================================================\n\n**CountdownLatch in "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/countdownlatch/countdownlatch.cpp",
"chars": 718,
"preview": "#include <chrono>\n#include \"countdownlatch.hpp\"\n\nclatch::countdownlatch::countdownlatch(uint32_t count) {\n this->count"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/countdownlatch/countdownlatch.hpp",
"chars": 1382,
"preview": "#ifndef __COUNTDOWNLATCH_NIPUN__\n#define __COUNTDOWNLATCH_NIPUN__\n\n#include <cinttypes>\n#include <cstdint>\n#include <mut"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/optional/COPYING",
"chars": 7048,
"preview": "Creative Commons Legal Code\n\nCC0 1.0 Universal\n\n CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/optional/README.md",
"chars": 4541,
"preview": "# optional\nSingle header implementation of `std::optional` with functional-style extensions and support for references.\n"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/optional/tl/optional.hpp",
"chars": 84021,
"preview": "\n///\n// optional - An implementation of std::optional with extensions\n// Written in 2017 by Simon Brand (tartanllama@gma"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/ordered-map/LICENSE",
"chars": 1063,
"preview": "MIT License\n\nCopyright (c) 2017 Tessil\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/ordered-map/README.md",
"chars": 11468,
"preview": "[](https://travis-ci.org/Tessil/ordered-map) "
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/ordered-map/include/tsl/ordered_hash.h",
"chars": 51110,
"preview": "/**\n * MIT License\n * \n * Copyright (c) 2017 Tessil\n * \n * Permission is hereby granted, free of charge, to any person o"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/ordered-map/include/tsl/ordered_map.h",
"chars": 31267,
"preview": "/**\n * MIT License\n * \n * Copyright (c) 2017 Tessil\n * \n * Permission is hereby granted, free of charge, to any person o"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/ordered-map/include/tsl/ordered_set.h",
"chars": 25872,
"preview": "/**\n * MIT License\n * \n * Copyright (c) 2017 Tessil\n * \n * Permission is hereby granted, free of charge, to any person o"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/spdlog/LICENSE",
"chars": 1322,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2016 Gabi Melman. \n\nPermission is hereby gran"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/spdlog/README.md",
"chars": 15689,
"preview": "# spdlog\n\nVery fast, header-only/compiled, C++ logging library. [![Build Status](https://app.travis-ci.com/gabime/spdlog"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/spdlog/cmake/ide.cmake",
"chars": 1190,
"preview": "# ---------------------------------------------------------------------------------------\n# IDE support for headers\n# --"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/spdlog/cmake/spdlog.pc.in",
"chars": 376,
"preview": "prefix=@CMAKE_INSTALL_PREFIX@\nexec_prefix=${prefix}\nincludedir=${prefix}/include\nlibdir=${exec_prefix}/@CMAKE_INSTALL_LI"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/spdlog/cmake/spdlogCPack.cmake",
"chars": 2716,
"preview": "set(CPACK_GENERATOR \"TGZ;ZIP\" CACHE STRING \"Semicolon separated list of generators\")\n\nset(CPACK_INCLUDE_TOPLEVEL_DIRECTO"
},
{
"path": "src/cpp/RiderLink/Source/RD/thirdparty/spdlog/cmake/spdlogConfig.cmake.in",
"chars": 530,
"preview": "# Copyright(c) 2019 spdlog authors\n# Distributed under the MIT License (http://opensource.org/licenses/MIT)\n\n@PACKAGE_IN"
}
]
// ... and 290 more files (download for full content)
About this extraction
This page contains the full source code of the JetBrains/UnrealLink GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 490 files (2.2 MB), approximately 607.1k tokens, and a symbol index with 1872 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.