Transmission/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission.git synced 2025-12-20 02:18:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: unify quarks and strings to snake_case (#7108)

Browse Source 
* refactor: change `leftUntilDone` to `left_until_done`

* refactor: change `magnetLink` to `magnet_link`

* refactor: change `manualAnnounceTime` to `manual_announce_time`

* refactor: change `maxConnectedPeers` to `max_connected_peers`

* refactor: change `metadataPercentComplete` to `metadata_percent_complete`

* refactor: change `peersConnected` to `peers_connected`

* refactor: change `peersFrom` to `peers_from`

* refactor: change `peersGettingFromUs` to `peers_getting_from_us`

* refactor: change `peersSendingToUs` to `peers_sending_to_us`

* refactor: change `percentComplete` to `percent_complete`

* refactor: change `percentDone` to `percent_done`

* refactor: change `pieceCount` to `piece_count`

* refactor: use quark when possible

* refactor: change `pieceSize` to `piece_size`

* refactor: change `primary-mime-type` to `primary_mime_type`

* refactor: change `rateDownload` to `rate_download`

* refactor: change `rateUpload` to `rate_upload`

* refactor: change `recheckProgress` to `recheck_progress`

* refactor: change `secondsDownloading` to `seconds_downloading`

* refactor: change `secondsSeeding` to `seconds_seeding`

* refactor: change `sizeWhenDone` to `size_when_done`

* refactor: change `startDate` to `start_date`

* refactor: change `trackerStats` to `tracker_stats`

* refactor: change `totalSize` to `total_size`

* refactor: change `torrentFile` to `torrent_file`

* refactor: change `uploadedEver` to `uploaded_ever`

* refactor: change `uploadRatio` to `upload_ratio`

* refactor: change `webseedsSendingToUs` to `webseeds_sending_to_us`

* refactor: change `bytesCompleted` to `bytes_completed`

* refactor: change `clientName` to `client_name`

* refactor: change `clientIsChoked` to `client_is_choked`

* refactor: change `clientIsInterested` to `client_is_interested`

* refactor: change `flagStr` to `flag_str`

* refactor: change `isDownloadingFrom` to `is_downloading_from`

* refactor: change `isEncrypted` to `is_encrypted`

* refactor: change `isIncoming` to `is_incoming`

* refactor: change `isUploadingTo` to `is_uploading_to`

* refactor: change `isUTP` to `is_utp`

* refactor: change `peerIsChoked` to `peer_is_choked`

* refactor: change `peerIsInterested` to `peer_is_interested`

* refactor: change `rateToClient` to `rate_to_client`

* refactor: change `rateToPeer` to `rate_to_peer`

* refactor: change `fromCache` to `from_cache`

* refactor: change `fromDht` to `from_dht`

* refactor: change `fromIncoming` to `from_incoming`

* refactor: change `fromLpd` to `from_lpd`

* refactor: change `fromLtep` to `from_ltep`

* refactor: change `fromPex` to `from_pex`

* refactor: change `fromTracker` to `from_tracker`

* refactor: change `announceState` to `announce_state`

* refactor: change `downloadCount` to `download_count`

* refactor: change `hasAnnounced` to `has_announced`

* refactor: change `hasScraped` to `has_scraped`

* refactor: change `isBackup` to `is_backup`

* refactor: change `lastAnnouncePeerCount` to `last_announce_peer_count`

* refactor: change `lastAnnounceResult` to `last_announce_result`

* refactor: change `lastAnnounceStartTime` to `last_announce_start_time`

* refactor: change `lastAnnounceSucceeded` to `last_announce_succeeded`

* refactor: change `lastAnnounceTime` to `last_announce_time`

* refactor: change `lastAnnounceTimedOut` to `last_announce_timed_out`

* refactor: change `lastScrapeResult` to `last_scrape_result`

* refactor: change `lastScrapeStartTime` to `last_scrape_start_time`

* refactor: change `lastScrapeSucceeded` to `last_scrape_succeeded`

* refactor: change `lastScrapeTime` to `last_scrape_time`

* refactor: change `lastScrapeTimedOut` to `last_scrape_timed_out`

* refactor: change `leecherCount` to `leecher_count`

* refactor: change `nextAnnounceTime` to `next_announce_time`

* refactor: change `nextScrapeTime` to `next_scrape_time`

* refactor: change `scrapeState` to `scrape_state`

* refactor: change `seederCount` to `seeder_count`

* refactor: change `torrent-added` to `torrent_added`

* refactor: change `torrent-duplicate` to `torrent_duplicate`

* refactor: change `torrent-remove` to `torrent_remove`

* refactor: change `delete-local-data` to `delete_local_data`

* refactor: change `torrent-rename-path` to `torrent_rename_path`

* refactor: change `alt-speed-down` to `alt_speed_down`

* refactor: convert `pref_toggle_entries` to quark array

* refactor: change `alt-speed-enabled` to `alt_speed_enabled`

* refactor: change `compact-view` to `compact_view`

* refactor: change `sort-reversed` to `sort_reversed`

* refactor: change `show-filterbar` to `show_filterbar`

* refactor: change `show-statusbar` to `show_statusbar`

* refactor: change `show-toolbar` to `show_toolbar`

* refactor: change `alt-speed-time-begin` to `alt_speed_time_begin`

* refactor: change `alt-speed-time-day` to `alt_speed_time_day`

* refactor: change `alt-speed-time-end` to `alt_speed_time_end`

* refactor: change `alt-speed-up` to `alt_speed_up`

* refactor: change `alt-speed-time-enabled` to `alt_speed_time_enabled`

* refactor: change `blocklist-enabled` to `blocklist_enabled`

* refactor: change `blocklist-size` to `blocklist_size`

* refactor: change `blocklist-url` to `blocklist_url`

* refactor: change `cache-size-mb` to `cache_size_mb`

* refactor: change `config-dir` to `config_dir`

* refactor: change `default-trackers` to `default_trackers`

* refactor: change `dht-enabled` to `dht_enabled`

* refactor: change `download-dir-free-space` to `download_dir_free_space`

* refactor: change `download-queue-enabled` to `download_queue_enabled`

* refactor: change `download-queue-size` to `download_queue_size`

* refactor: change `idle-seeding-limit-enabled` to `idle_seeding_limit_enabled`

* refactor: change `idle-seeding-limit` to `idle_seeding_limit`

* refactor: change `incomplete-dir-enabled` to `incomplete_dir_enabled`

* refactor: change `incomplete-dir` to `incomplete_dir`

* refactor: change `lpd-enabled` to `lpd_enabled`

* refactor: change `peer-limit-global` to `peer_limit_global`

* refactor: change `peer-limit-per-torrent` to `peer_limit_per_torrent`

* refactor: change `peer-port-random-on-start` to `peer_port_random_on_start`

* refactor: change `peer-port` to `peer_port`

* refactor: change `pex-enabled` to `pex_enabled`

* refactor: change `port-forwarding-enabled` to `port_forwarding_enabled`

* refactor: change `queue-stalled-enabled` to `queue_stalled_enabled`

* refactor: change `queue-stalled-minutes` to `queue_stalled_minutes`

* refactor: change `rename-partial-files` to `rename_partial_files`

* refactor: change `rpc-version-minimum` to `rpc_version_minimum`

* refactor: change `rpc-version-semver` to `rpc_version_semver`

* refactor: change `rpc-version` to `rpc_version`

* refactor: change `script-torrent-added-enabled` to `script_torrent_added_enabled`

* refactor: change `script-torrent-added-filename` to `script_torrent_added_filename`

* refactor: change `script-torrent-done-enabled` to `script_torrent_done_enabled`

* refactor: change `script-torrent-done-filename` to `script_torrent_done_filename`

* refactor: change `script-torrent-done-seeding-enabled` to `script_torrent_done_seeding_enabled`

* refactor: change `script-torrent-done-seeding-filename` to `script_torrent_done_seeding_filename`

* refactor: change `seed-queue-enabled` to `seed_queue_enabled`

* refactor: change `seed-queue-size` to `seed_queue_size`

* refactor: change `seedRatioLimited` to `seed_ratio_limited`

* refactor: change `session-id` to `session_id`

* refactor: change `speed-limit-down-enabled` to `speed_limit_down_enabled`

* refactor: change `speed-limit-down` to `speed_limit_down`

* refactor: change `speed-limit-up-enabled` to `speed_limit_up_enabled`

* refactor: change `speed-limit-up` to `speed_limit_up`

* refactor: change `start-added-torrents` to `start_added_torrents`

* refactor: change `trash-original-torrent-files` to `trash_original_torrent_files`

* refactor: change `utp-enabled` to `utp_enabled`

* refactor: change `tcp-enabled` to `tcp_enabled`

* docs: add missing docs for RPC `tcp_enabled`

* refactor: change `speed-units` to `speed_units`

* refactor: change `speed-bytes` to `speed_bytes`

* refactor: change `size-units` to `size_units`

* refactor: change `size-bytes` to `size_bytes`

* refactor: change `memory-units` to `memory_units`

* refactor: change `memory-bytes` to `memory_bytes`

* refactor: change `session-set` to `session_set`

* refactor: change `session-get` to `session_get`

* refactor: change `session-stats` to `session_stats`

* refactor: change `activeTorrentCount` to `active_torrent_count`

* refactor: change `downloadSpeed` to `download_speed`

* refactor: change `pausedTorrentCount` to `paused_torrent_count`

* refactor: change `torrentCount` to `torrent_count`

* refactor: change `uploadSpeed` to `upload_speed`

* refactor: change `cumulative-stats` to `cumulative_stats`

* refactor: change `current-stats` to `current_stats`

* refactor: change `uploadedBytes` and `uploaded-bytes` to `uploaded_bytes`

* refactor: change `downloadedBytes` and `downloaded-bytes` to `downloaded_bytes`

* refactor: change `filesAdded` and `files-added` to `files_added`

* refactor: change `sessionCount` and `session-count` to `session_count`

* refactor: change `secondsActive` and `seconds-active` to `seconds_active`

* refactor: change `blocklist-update` to `blocklist_update`

* refactor: change `port-test` to `port_test`

* refactor: change `session-close` to `session_close`

* refactor: change `queue-move-top` to `queue_move_top`

* refactor: change `queue-move-up` to `queue_move_up`

* refactor: change `queue-move-down` to `queue_move_down`

* refactor: change `queue-move-bottom` to `queue_move_bottom`

* refactor: change `free-space` to `free_space`

* refactor: change `group-set` to `group_set`

* refactor: change `group-get` to `group_get`

* refactor: change `announce-ip` to `announce_ip`

* refactor: change `announce-ip-enabled` to `announce_ip_enabled`

* refactor: change `upload-slots-per-torrent` to `upload_slots_per_torrent`

* refactor: change `trash-can-enabled` to `trash_can_enabled`

* refactor: change `watch-dir-enabled` to `watch_dir_enabled`

* refactor: change `watch-dir-force-generic` to `watch_dir_force_generic`

* refactor: change `watch-dir` to `watch_dir`

* refactor: change `message-level` to `message_level`

* refactor: change `scrape-paused-torrents-enabled` to `scrape_paused_torrents_enabled`

* refactor: change `torrent-added-verify-mode` to `torrent_added_verify_mode`

* refactor: change `sleep-per-seconds-during-verify` to `sleep_per_seconds_during_verify`

* refactor: change `bind-address-ipv4` to `bind_address_ipv4`

* refactor: change `bind-address-ipv6` to `bind_address_ipv6`

* refactor: change `peer-congestion-algorithm` to `peer_congestion_algorithm`

* refactor: change `peer-socket-tos` to `peer_socket_tos`

* refactor: change `peer-port-random-high` to `peer_port_random_high`

* refactor: change `peer-port-random-low` to `peer_port_random_low`

* refactor: change `anti-brute-force-enabled` to `anti_brute_force_enabled`

* refactor: change `rpc-authentication-required` to `rpc_authentication_required`

* refactor: change `rpc-bind-address` to `rpc_bind_address`

* refactor: change `rpc-enabled` to `rpc_enabled`

* refactor: change `rpc-host-whitelist` to `rpc_host_whitelist`

* refactor: change `rpc-host-whitelist-enabled` to `rpc_host_whitelist_enabled`

* refactor: change `rpc-password` to `rpc_password`

* refactor: change `rpc-port` to `rpc_port`

* refactor: change `rpc-socket-mode` to `rpc_socket_mode`

* refactor: change `rpc-url` to `rpc_url`

* refactor: change `rpc-username` to `rpc_username`

* refactor: change `rpc-whitelist` to `rpc_whitelist`

* refactor: change `rpc-whitelist-enabled` to `rpc_whitelist_enabled`

* refactor: change `ratio-limit-enabled` to `ratio_limit_enabled`

* refactor: change `ratio-limit` to `ratio_limit`

* refactor: change `show-options-window` to `show_options_window`

* refactor: change `open-dialog-dir` to `open_dialog_dir`

* refactor: change `inhibit-desktop-hibernation` to `inhibit_desktop_hibernation`

* refactor: change `show-notification-area-icon` to `show_notification_area_icon`

* refactor: change `start-minimized` to `start_minimized`

* refactor: change `torrent-added-notification-enabled` to `torrent_added_notification_enabled`

* refactor: change `anti-brute-force-threshold` to `anti_brute_force_threshold`

* refactor: change `torrent-complete-notification-enabled` to `torrent_complete_notification_enabled`

* refactor: change `prompt-before-exit` to `prompt_before_exit`

* refactor: change `sort-mode` to `sort_mode`

* refactor: change `statusbar-stats` to `statusbar_stats`

* refactor: change `show-extra-peer-details` to `show_extra_peer_details`

* refactor: change `show-backup-trackers` to `show_backup_trackers`

* refactor: change `blocklist-date` to `blocklist_date`

* refactor: change `blocklist-updates-enabled` to `blocklist_updates_enabled`

* refactor: change `main-window-layout-order` to `main_window_layout_order`

* refactor: change `main-window-height` to `main_window_height`

* refactor: change `main-window-width` to `main_window_width`

* refactor: change `main-window-x` to `main_window_x`

* refactor: change `main-window-y` to `main_window_y`

* refactor: change `filter-mode` to `filter_mode`

* refactor: change `filter-trackers` to `filter_trackers`

* refactor: change `filter-text` to `filter_text`

* refactor: change `remote-session-enabled` to `remote_session_enabled`

* refactor: change `remote-session-host` to `remote_session_host`

* refactor: change `remote-session-https` to `remote_session_https`

* refactor: change `remote-session-password` to `remote_session_password`

* refactor: change `remote-session-port` to `remote_session_port`

* refactor: change `remote-session-requres-authentication` to `remote_session_requires_authentication`

* refactor: change `remote-session-username` to `remote_session_username`

* refactor: change `torrent-complete-sound-command` to `torrent_complete_sound_command`

* refactor: change `torrent-complete-sound-enabled` to `torrent_complete_sound_enabled`

* refactor: change `user-has-given-informed-consent` to `user_has_given_informed_consent`

* refactor: change `read-clipboard` to `read_clipboard`

* refactor: change `details-window-height` to `details_window_height`

* refactor: change `details-window-width` to `details_window_width`

* refactor: change `main-window-is-maximized` to `main_window_is_maximized`

* refactor: change `port-is-open` to `port_is_open`

* refactor: change `show-tracker-scrapes` to `show_tracker_scrapes`

* refactor: change `max-peers` to `max_peers`

* refactor: change `peers2-6` to `peers2_6`

* refactor: change `seeding-time-seconds` to `seeding_time_seconds`

* refactor: change `downloading-time-seconds` to `downloading_time_seconds`

* refactor: change `ratio-mode` to `ratio_mode`

* refactor: change `idle-limit` to `idle_limit`

* refactor: change `idle-mode` to `idle_mode`

* refactor: change `speed-Bps` to `speed_Bps`

* refactor: change `use-global-speed-limit` to `use_global_speed_limit`

* refactor: change `use-speed-limit` to `use_speed_limit`

* chore: remove TODO comment

* docs: add upgrade instructions to `5.0.0`

* chore: bump rpc semver major version

* chore: housekeeping
This commit is contained in:
Yat Ho
2025-12-02 06:08:18 +08:00
committed by GitHub
parent 030b22f91c
commit 05aef3e787
43 changed files with 3244 additions and 1815 deletions
Download Patch File Download Diff File Expand all files Collapse all files

571
libtransmission/quark.cc
View File

@@ -21,14 +21,17 @@ namespace
auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
""sv,
"activeTorrentCount"sv,
"active_torrent_count"sv,
"activity-date"sv,
"activityDate"sv,
"activity_date"sv,
"added"sv,
"added-date"sv,
"added.f"sv,
"added6"sv,
"added6.f"sv,
"addedDate"sv,
"added_date"sv,
"address"sv,
"alt-speed-down"sv,
"alt-speed-enabled"sv,
@@ -37,60 +40,98 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"alt-speed-time-enabled"sv,
"alt-speed-time-end"sv,
"alt-speed-up"sv,
"alt_speed_down"sv,
"alt_speed_enabled"sv,
"alt_speed_time_begin"sv,
"alt_speed_time_day"sv,
"alt_speed_time_enabled"sv,
"alt_speed_time_end"sv,
"alt_speed_up"sv,
"announce"sv,
"announce-ip"sv,
"announce-ip-enabled"sv,
"announce-list"sv,
"announceState"sv,
"announce_ip"sv,
"announce_ip_enabled"sv,
"announce_state"sv,
"anti-brute-force-enabled"sv,
"anti-brute-force-threshold"sv,
"anti_brute_force_enabled"sv,
"anti_brute_force_threshold"sv,
"arguments"sv,
"availability"sv,
"bandwidth-priority"sv,
"bandwidthPriority"sv,
"bandwidth_priority"sv,
"begin_piece"sv,
"bind-address-ipv4"sv,
"bind-address-ipv6"sv,
"bind_address_ipv4"sv,
"bind_address_ipv6"sv,
"bitfield"sv,
"blocklist-date"sv,
"blocklist-enabled"sv,
"blocklist-size"sv,
"blocklist-updates-enabled"sv,
"blocklist-url"sv,
"blocklist_date"sv,
"blocklist_enabled"sv,
"blocklist_size"sv,
"blocklist_updates_enabled"sv,
"blocklist_url"sv,
"blocks"sv,
"bytesCompleted"sv,
"bytes_completed"sv,
"bytes_to_client"sv,
"bytes_to_peer"sv,
"cache-size-mb"sv,
"cache_size_mb"sv,
"clientIsChoked"sv,
"clientIsInterested"sv,
"clientName"sv,
"client_is_choked"sv,
"client_is_interested"sv,
"client_name"sv,
"code"sv,
"comment"sv,
"compact-view"sv,
"compact_view"sv,
"complete"sv,
"config-dir"sv,
"config_dir"sv,
"cookies"sv,
"corrupt"sv,
"corruptEver"sv,
"corrupt_ever"sv,
"created by"sv,
"creation date"sv,
"creator"sv,
"cumulative-stats"sv,
"cumulative_stats"sv,
"current-stats"sv,
"current_stats"sv,
"data"sv,
"date"sv,
"dateCreated"sv,
"date_created"sv,
"default-trackers"sv,
"default_trackers"sv,
"delete-local-data"sv,
"delete_local_data"sv,
"desiredAvailable"sv,
"desired_available"sv,
"destination"sv,
"details-window-height"sv,
"details-window-width"sv,
"details_window_height"sv,
"details_window_width"sv,
"dht-enabled"sv,
"dht_enabled"sv,
"dnd"sv,
"done-date"sv,
"doneDate"sv,
"done_date"sv,
"download-dir"sv,
"download-dir-free-space"sv,
"download-queue-enabled"sv,
@@ -100,36 +141,59 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"downloadLimit"sv,
"downloadLimited"sv,
"downloadSpeed"sv,
"download_count"sv,
"download_dir"sv,
"download_dir_free_space"sv,
"download_limit"sv,
"download_limited"sv,
"download_queue_enabled"sv,
"download_queue_size"sv,
"download_speed"sv,
"downloaded"sv,
"downloaded-bytes"sv,
"downloadedBytes"sv,
"downloadedEver"sv,
"downloaded_bytes"sv,
"downloaded_ever"sv,
"downloader_count"sv,
"downloading-time-seconds"sv,
"downloading_time_seconds"sv,
"dropped"sv,
"dropped6"sv,
"e"sv,
"editDate"sv,
"edit_date"sv,
"encoding"sv,
"encryption"sv,
"end_piece"sv,
"error"sv,
"errorString"sv,
"error_string"sv,
"eta"sv,
"etaIdle"sv,
"eta_idle"sv,
"fields"sv,
"file-count"sv,
"fileStats"sv,
"file_count"sv,
"file_stats"sv,
"filename"sv,
"files"sv,
"files-added"sv,
"files-unwanted"sv,
"files-wanted"sv,
"filesAdded"sv,
"files_added"sv,
"files_unwanted"sv,
"files_wanted"sv,
"filter-mode"sv,
"filter-text"sv,
"filter-trackers"sv,
"filter_mode"sv,
"filter_text"sv,
"filter_trackers"sv,
"flagStr"sv,
"flag_str"sv,
"flags"sv,
"format"sv,
"fromCache"sv,
@@ -139,14 +203,27 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"fromLtep"sv,
"fromPex"sv,
"fromTracker"sv,
"from_cache"sv,
"from_dht"sv,
"from_incoming"sv,
"from_lpd"sv,
"from_ltep"sv,
"from_pex"sv,
"from_tracker"sv,
"group"sv,
"hasAnnounced"sv,
"hasScraped"sv,
"has_announced"sv,
"has_scraped"sv,
"hashString"sv,
"hash_string"sv,
"have"sv,
"haveUnchecked"sv,
"haveValid"sv,
"have_unchecked"sv,
"have_valid"sv,
"honorsSessionLimits"sv,
"honors_session_limits"sv,
"host"sv,
"id"sv,
"id_timestamp"sv,
@@ -154,12 +231,19 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"idle-mode"sv,
"idle-seeding-limit"sv,
"idle-seeding-limit-enabled"sv,
"idle_limit"sv,
"idle_mode"sv,
"idle_seeding_limit"sv,
"idle_seeding_limit_enabled"sv,
"ids"sv,
"incomplete"sv,
"incomplete-dir"sv,
"incomplete-dir-enabled"sv,
"incomplete_dir"sv,
"incomplete_dir_enabled"sv,
"info"sv,
"inhibit-desktop-hibernation"sv,
"inhibit_desktop_hibernation"sv,
"ip_protocol"sv,
"ipv4"sv,
"ipv6"sv,
@@ -172,6 +256,15 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"isStalled"sv,
"isUTP"sv,
"isUploadingTo"sv,
"is_backup"sv,
"is_downloading_from"sv,
"is_encrypted"sv,
"is_finished"sv,
"is_incoming"sv,
"is_private"sv,
"is_stalled"sv,
"is_uploading_to"sv,
"is_utp"sv,
"jsonrpc"sv,
"labels"sv,
"lastAnnouncePeerCount"sv,
@@ -185,27 +278,55 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"lastScrapeSucceeded"sv,
"lastScrapeTime"sv,
"lastScrapeTimedOut"sv,
"last_announce_peer_count"sv,
"last_announce_result"sv,
"last_announce_start_time"sv,
"last_announce_succeeded"sv,
"last_announce_time"sv,
"last_announce_timed_out"sv,
"last_scrape_result"sv,
"last_scrape_start_time"sv,
"last_scrape_succeeded"sv,
"last_scrape_time"sv,
"last_scrape_timed_out"sv,
"leecherCount"sv,
"leecher_count"sv,
"leftUntilDone"sv,
"left_until_done"sv,
"length"sv,
"location"sv,
"lpd-enabled"sv,
"lpd_enabled"sv,
"m"sv,
"magnetLink"sv,
"magnet_link"sv,
"main-window-height"sv,
"main-window-is-maximized"sv,
"main-window-layout-order"sv,
"main-window-width"sv,
"main-window-x"sv,
"main-window-y"sv,
"main_window_height"sv,
"main_window_is_maximized"sv,
"main_window_layout_order"sv,
"main_window_width"sv,
"main_window_x"sv,
"main_window_y"sv,
"manualAnnounceTime"sv,
"manual_announce_time"sv,
"max-peers"sv,
"maxConnectedPeers"sv,
"max_connected_peers"sv,
"max_peers"sv,
"memory-bytes"sv,
"memory-units"sv,
"memory_bytes"sv,
"memory_units"sv,
"message"sv,
"message-level"sv,
"message_level"sv,
"metadataPercentComplete"sv,
"metadata_percent_complete"sv,
"metadata_size"sv,
"metainfo"sv,
"method"sv,
@@ -215,14 +336,18 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"name"sv,
"nextAnnounceTime"sv,
"nextScrapeTime"sv,
"next_announce_time"sv,
"next_scrape_time"sv,
"nodes"sv,
"nodes6"sv,
"open-dialog-dir"sv,
"open_dialog_dir"sv,
"p"sv,
"params"sv,
"path"sv,
"paused"sv,
"pausedTorrentCount"sv,
"paused_torrent_count"sv,
"peer-congestion-algorithm"sv,
"peer-limit"sv,
"peer-limit-global"sv,
@@ -234,50 +359,90 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"peer-socket-tos"sv,
"peerIsChoked"sv,
"peerIsInterested"sv,
"peer_congestion_algorithm"sv,
"peer_id"sv,
"peer_is_choked"sv,
"peer_is_interested"sv,
"peer_limit"sv,
"peer_limit_global"sv,
"peer_limit_per_torrent"sv,
"peer_port"sv,
"peer_port_random_high"sv,
"peer_port_random_low"sv,
"peer_port_random_on_start"sv,
"peer_socket_tos"sv,
"peers"sv,
"peers2"sv,
"peers2-6"sv,
"peers2_6"sv,
"peersConnected"sv,
"peersFrom"sv,
"peersGettingFromUs"sv,
"peersSendingToUs"sv,
"peers_connected"sv,
"peers_from"sv,
"peers_getting_from_us"sv,
"peers_sending_to_us"sv,
"percentComplete"sv,
"percentDone"sv,
"percent_complete"sv,
"percent_done"sv,
"pex-enabled"sv,
"pex_enabled"sv,
"pidfile"sv,
"piece"sv,
"piece length"sv,
"pieceCount"sv,
"pieceSize"sv,
"piece_count"sv,
"piece_size"sv,
"pieces"sv,
"port"sv,
"port-forwarding-enabled"sv,
"port-is-open"sv,
"port_forwarding_enabled"sv,
"port_is_open"sv,
"preallocation"sv,
"preferred_transports"sv,
"primary-mime-type"sv,
"primary_mime_type"sv,
"priorities"sv,
"priority"sv,
"priority-high"sv,
"priority-low"sv,
"priority-normal"sv,
"priority_high"sv,
"priority_low"sv,
"priority_normal"sv,
"private"sv,
"progress"sv,
"prompt-before-exit"sv,
"prompt_before_exit"sv,
"proxy_url"sv,
"queue-stalled-enabled"sv,
"queue-stalled-minutes"sv,
"queuePosition"sv,
"queue_position"sv,
"queue_stalled_enabled"sv,
"queue_stalled_minutes"sv,
"rateDownload"sv,
"rateToClient"sv,
"rateToPeer"sv,
"rateUpload"sv,
"rate_download"sv,
"rate_to_client"sv,
"rate_to_peer"sv,
"rate_upload"sv,
"ratio-limit"sv,
"ratio-limit-enabled"sv,
"ratio-mode"sv,
"ratio_limit"sv,
"ratio_limit_enabled"sv,
"ratio_mode"sv,
"read-clipboard"sv,
"read_clipboard"sv,
"recheckProgress"sv,
"recheck_progress"sv,
"remote-session-enabled"sv,
"remote-session-host"sv,
"remote-session-https"sv,
@@ -285,9 +450,17 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"remote-session-port"sv,
"remote-session-requres-authentication"sv,
"remote-session-username"sv,
"remote_session_enabled"sv,
"remote_session_host"sv,
"remote_session_https"sv,
"remote_session_password"sv,
"remote_session_port"sv,
"remote_session_requires_authentication"sv,
"remote_session_rpc_url_path"sv,
"remote_session_username"sv,
"removed"sv,
"rename-partial-files"sv,
"rename_partial_files"sv,
"reqq"sv,
"result"sv,
"rpc-authentication-required"sv,
@@ -305,19 +478,45 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"rpc-version-semver"sv,
"rpc-whitelist"sv,
"rpc-whitelist-enabled"sv,
"rpc_authentication_required"sv,
"rpc_bind_address"sv,
"rpc_enabled"sv,
"rpc_host_whitelist"sv,
"rpc_host_whitelist_enabled"sv,
"rpc_password"sv,
"rpc_port"sv,
"rpc_socket_mode"sv,
"rpc_url"sv,
"rpc_username"sv,
"rpc_version"sv,
"rpc_version_minimum"sv,
"rpc_version_semver"sv,
"rpc_whitelist"sv,
"rpc_whitelist_enabled"sv,
"scrape"sv,
"scrape-paused-torrents-enabled"sv,
"scrapeState"sv,
"scrape_paused_torrents_enabled"sv,
"scrape_state"sv,
"script-torrent-added-enabled"sv,
"script-torrent-added-filename"sv,
"script-torrent-done-enabled"sv,
"script-torrent-done-filename"sv,
"script-torrent-done-seeding-enabled"sv,
"script-torrent-done-seeding-filename"sv,
"script_torrent_added_enabled"sv,
"script_torrent_added_filename"sv,
"script_torrent_done_enabled"sv,
"script_torrent_done_filename"sv,
"script_torrent_done_seeding_enabled"sv,
"script_torrent_done_seeding_filename"sv,
"seconds-active"sv,
"secondsActive"sv,
"secondsDownloading"sv,
"secondsSeeding"sv,
"seconds_active"sv,
"seconds_downloading"sv,
"seconds_seeding"sv,
"seed-queue-enabled"sv,
"seed-queue-size"sv,
"seedIdleLimit"sv,
@@ -325,13 +524,24 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"seedRatioLimit"sv,
"seedRatioLimited"sv,
"seedRatioMode"sv,
"seed_idle_limit"sv,
"seed_idle_mode"sv,
"seed_queue_enabled"sv,
"seed_queue_size"sv,
"seed_ratio_limit"sv,
"seed_ratio_limited"sv,
"seed_ratio_mode"sv,
"seederCount"sv,
"seeder_count"sv,
"seeding-time-seconds"sv,
"seeding_time_seconds"sv,
"sequential_download"sv,
"sequential_download_from_piece"sv,
"session-count"sv,
"session-id"sv,
"sessionCount"sv,
"session_count"sv,
"session_id"sv,
"show-backup-trackers"sv,
"show-extra-peer-details"sv,
"show-filterbar"sv,
@@ -340,14 +550,27 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"show-statusbar"sv,
"show-toolbar"sv,
"show-tracker-scrapes"sv,
"show_backup_trackers"sv,
"show_extra_peer_details"sv,
"show_filterbar"sv,
"show_notification_area_icon"sv,
"show_options_window"sv,
"show_statusbar"sv,
"show_toolbar"sv,
"show_tracker_scrapes"sv,
"sitename"sv,
"size-bytes"sv,
"size-units"sv,
"sizeWhenDone"sv,
"sleep-per-seconds-during-verify"sv,
"size_bytes"sv,
"size_units"sv,
"size_when_done"sv,
"sleep_per_seconds_during_verify"sv,
"socket_address"sv,
"sort-mode"sv,
"sort-reversed"sv,
"sort_mode"sv,
"sort_reversed"sv,
"source"sv,
"speed"sv,
"speed-Bps"sv,
@@ -357,14 +580,26 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"speed-limit-up"sv,
"speed-limit-up-enabled"sv,
"speed-units"sv,
"speed_Bps"sv,
"speed_bytes"sv,
"speed_limit_down"sv,
"speed_limit_down_enabled"sv,
"speed_limit_up"sv,
"speed_limit_up_enabled"sv,
"speed_units"sv,
"start-added-torrents"sv,
"start-minimized"sv,
"startDate"sv,
"start_added_torrents"sv,
"start_date"sv,
"start_minimized"sv,
"start_paused"sv,
"status"sv,
"statusbar-stats"sv,
"statusbar_stats"sv,
"tag"sv,
"tcp-enabled"sv,
"tcp_enabled"sv,
"tier"sv,
"time-checked"sv,
"torrent-added"sv,
@@ -381,7 +616,19 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"torrent-set-location"sv,
"torrentCount"sv,
"torrentFile"sv,
"torrent_added"sv,
"torrent_added_notification_enabled"sv,
"torrent_added_verify_mode"sv,
"torrent_complete_notification_enabled"sv,
"torrent_complete_sound_command"sv,
"torrent_complete_sound_enabled"sv,
"torrent_complete_verify_enabled"sv,
"torrent_count"sv,
"torrent_duplicate"sv,
"torrent_file"sv,
"torrent_get"sv,
"torrent_set"sv,
"torrent_set_location"sv,
"torrents"sv,
"totalSize"sv,
"total_size"sv,
@@ -390,9 +637,16 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"trackerRemove"sv,
"trackerReplace"sv,
"trackerStats"sv,
"tracker_add"sv,
"tracker_list"sv,
"tracker_remove"sv,
"tracker_replace"sv,
"tracker_stats"sv,
"trackers"sv,
"trash-can-enabled"sv,
"trash-original-torrent-files"sv,
"trash_can_enabled"sv,
"trash_original_torrent_files"sv,
"umask"sv,
"units"sv,
"upload-slots-per-torrent"sv,
@@ -400,27 +654,42 @@ auto constexpr MyStatic = std::array<std::string_view, TR_N_KEYS>{
"uploadLimited"sv,
"uploadRatio"sv,
"uploadSpeed"sv,
"upload_limit"sv,
"upload_limited"sv,
"upload_only"sv,
"upload_ratio"sv,
"upload_slots_per_torrent"sv,
"upload_speed"sv,
"uploaded"sv,
"uploaded-bytes"sv,
"uploadedBytes"sv,
"uploadedEver"sv,
"uploaded_bytes"sv,
"uploaded_ever"sv,
"url-list"sv,
"use-global-speed-limit"sv,
"use-speed-limit"sv,
"use_global_speed_limit"sv,
"use_speed_limit"sv,
"user-has-given-informed-consent"sv,
"user_has_given_informed_consent"sv,
"ut_holepunch"sv,
"ut_metadata"sv,
"ut_pex"sv,
"utp-enabled"sv,
"utp_enabled"sv,
"v"sv,
"version"sv,
"wanted"sv,
"watch-dir"sv,
"watch-dir-enabled"sv,
"watch-dir-force-generic"sv,
"watch_dir"sv,
"watch_dir_enabled"sv,
"watch_dir_force_generic"sv,
"webseeds"sv,
"webseedsSendingToUs"sv,
"webseeds_sending_to_us"sv,
"yourip"sv,
};
@@ -486,3 +755,303 @@ std::string_view tr_quark_get_string_view(tr_quark q)
{
return q < TR_N_KEYS ? MyStatic[q] : my_runtime[q - TR_N_KEYS];
}
tr_quark tr_quark_convert(tr_quark q)
{
// clang-format off
switch (q)
{
case TR_KEY_active_torrent_count_camel: return TR_KEY_active_torrent_count;
case TR_KEY_activity_date_camel:
case TR_KEY_activity_date_kebab:
return TR_KEY_activity_date;
case TR_KEY_added_date_camel:
case TR_KEY_added_date_kebab:
return TR_KEY_added_date;
case TR_KEY_alt_speed_down_kebab: return TR_KEY_alt_speed_down;
case TR_KEY_alt_speed_enabled_kebab: return TR_KEY_alt_speed_enabled;
case TR_KEY_alt_speed_time_begin_kebab: return TR_KEY_alt_speed_time_begin;
case TR_KEY_alt_speed_time_day_kebab: return TR_KEY_alt_speed_time_day;
case TR_KEY_alt_speed_time_enabled_kebab: return TR_KEY_alt_speed_time_enabled;
case TR_KEY_alt_speed_time_end_kebab: return TR_KEY_alt_speed_time_end;
case TR_KEY_alt_speed_up_kebab: return TR_KEY_alt_speed_up;
case TR_KEY_announce_ip_kebab: return TR_KEY_announce_ip;
case TR_KEY_announce_ip_enabled_kebab: return TR_KEY_announce_ip_enabled;
case TR_KEY_announce_state_camel: return TR_KEY_announce_state;
case TR_KEY_anti_brute_force_enabled_kebab: return TR_KEY_anti_brute_force_enabled;
case TR_KEY_anti_brute_force_threshold_kebab: return TR_KEY_anti_brute_force_threshold;
case TR_KEY_bandwidth_priority_camel:
case TR_KEY_bandwidth_priority_kebab:
return TR_KEY_bandwidth_priority;
case TR_KEY_bind_address_ipv4_kebab: return TR_KEY_bind_address_ipv4;
case TR_KEY_bind_address_ipv6_kebab: return TR_KEY_bind_address_ipv6;
case TR_KEY_blocklist_date_kebab: return TR_KEY_blocklist_date;
case TR_KEY_blocklist_enabled_kebab: return TR_KEY_blocklist_enabled;
case TR_KEY_blocklist_size_kebab: return TR_KEY_blocklist_size;
case TR_KEY_blocklist_updates_enabled_kebab: return TR_KEY_blocklist_updates_enabled;
case TR_KEY_blocklist_url_kebab: return TR_KEY_blocklist_url;
case TR_KEY_bytes_completed_camel: return TR_KEY_bytes_completed;
case TR_KEY_cache_size_mb_kebab: return TR_KEY_cache_size_mb;
case TR_KEY_client_is_choked_camel: return TR_KEY_client_is_choked;
case TR_KEY_client_is_interested_camel: return TR_KEY_client_is_interested;
case TR_KEY_client_name_camel: return TR_KEY_client_name;
case TR_KEY_compact_view_kebab: return TR_KEY_compact_view;
case TR_KEY_config_dir_kebab: return TR_KEY_config_dir;
case TR_KEY_corrupt_ever_camel: return TR_KEY_corrupt_ever;
case TR_KEY_cumulative_stats_kebab: return TR_KEY_cumulative_stats;
case TR_KEY_current_stats_kebab: return TR_KEY_current_stats;
case TR_KEY_date_created_camel: return TR_KEY_date_created;
case TR_KEY_default_trackers_kebab: return TR_KEY_default_trackers;
case TR_KEY_delete_local_data_kebab: return TR_KEY_delete_local_data;
case TR_KEY_desired_available_camel: return TR_KEY_desired_available;
case TR_KEY_details_window_height_kebab: return TR_KEY_details_window_height;
case TR_KEY_details_window_width_kebab: return TR_KEY_details_window_width;
case TR_KEY_dht_enabled_kebab: return TR_KEY_dht_enabled;
case TR_KEY_done_date_camel:
case TR_KEY_done_date_kebab:
return TR_KEY_done_date;
case TR_KEY_download_count_camel: return TR_KEY_download_count;
case TR_KEY_download_dir_camel:
case TR_KEY_download_dir_kebab:
return TR_KEY_download_dir;
case TR_KEY_download_dir_free_space_kebab: return TR_KEY_download_dir_free_space;
case TR_KEY_download_limit_camel: return TR_KEY_download_limit;
case TR_KEY_download_limited_camel: return TR_KEY_download_limited;
case TR_KEY_download_queue_enabled_kebab: return TR_KEY_download_queue_enabled;
case TR_KEY_download_queue_size_kebab: return TR_KEY_download_queue_size;
case TR_KEY_download_speed_camel: return TR_KEY_download_speed;
case TR_KEY_downloaded_bytes_camel:
case TR_KEY_downloaded_bytes_kebab:
return TR_KEY_downloaded_bytes;
case TR_KEY_downloaded_ever_camel: return TR_KEY_downloaded_ever;
case TR_KEY_downloading_time_seconds_kebab: return TR_KEY_downloading_time_seconds;
case TR_KEY_edit_date_camel: return TR_KEY_edit_date;
case TR_KEY_error_string_camel: return TR_KEY_error_string;
case TR_KEY_eta_idle_camel: return TR_KEY_eta_idle;
case TR_KEY_file_count_kebab: return TR_KEY_file_count;
case TR_KEY_file_stats_camel: return TR_KEY_file_stats;
case TR_KEY_files_added_camel:
case TR_KEY_files_added_kebab:
return TR_KEY_files_added;
case TR_KEY_files_unwanted_kebab: return TR_KEY_files_unwanted;
case TR_KEY_files_wanted_kebab: return TR_KEY_files_wanted;
case TR_KEY_filter_mode_kebab: return TR_KEY_filter_mode;
case TR_KEY_filter_text_kebab: return TR_KEY_filter_text;
case TR_KEY_filter_trackers_kebab: return TR_KEY_filter_trackers;
case TR_KEY_flag_str_camel: return TR_KEY_flag_str;
case TR_KEY_from_cache_camel: return TR_KEY_from_cache;
case TR_KEY_from_dht_camel: return TR_KEY_from_dht;
case TR_KEY_from_incoming_camel: return TR_KEY_from_incoming;
case TR_KEY_from_lpd_camel: return TR_KEY_from_lpd;
case TR_KEY_from_ltep_camel: return TR_KEY_from_ltep;
case TR_KEY_from_pex_camel: return TR_KEY_from_pex;
case TR_KEY_from_tracker_camel: return TR_KEY_from_tracker;
case TR_KEY_hash_string_camel: return TR_KEY_hash_string;
case TR_KEY_has_announced_camel: return TR_KEY_has_announced;
case TR_KEY_has_scraped_camel: return TR_KEY_has_scraped;
case TR_KEY_have_unchecked_camel: return TR_KEY_have_unchecked;
case TR_KEY_have_valid_camel: return TR_KEY_have_valid;
case TR_KEY_honors_session_limits_camel: return TR_KEY_honors_session_limits;
case TR_KEY_idle_limit_kebab: return TR_KEY_idle_limit;
case TR_KEY_idle_mode_kebab: return TR_KEY_idle_mode;
case TR_KEY_idle_seeding_limit_kebab: return TR_KEY_idle_seeding_limit;
case TR_KEY_idle_seeding_limit_enabled_kebab: return TR_KEY_idle_seeding_limit_enabled;
case TR_KEY_incomplete_dir_kebab: return TR_KEY_incomplete_dir;
case TR_KEY_incomplete_dir_enabled_kebab: return TR_KEY_incomplete_dir_enabled;
case TR_KEY_inhibit_desktop_hibernation_kebab: return TR_KEY_inhibit_desktop_hibernation;
case TR_KEY_is_backup_camel: return TR_KEY_is_backup;
case TR_KEY_is_downloading_from_camel: return TR_KEY_is_downloading_from;
case TR_KEY_is_encrypted_camel: return TR_KEY_is_encrypted;
case TR_KEY_is_finished_camel: return TR_KEY_is_finished;
case TR_KEY_is_incoming_camel: return TR_KEY_is_incoming;
case TR_KEY_is_private_camel: return TR_KEY_is_private;
case TR_KEY_is_stalled_camel: return TR_KEY_is_stalled;
case TR_KEY_is_uploading_to_camel: return TR_KEY_is_uploading_to;
case TR_KEY_is_utp_camel: return TR_KEY_is_utp;
case TR_KEY_last_announce_peer_count_camel: return TR_KEY_last_announce_peer_count;
case TR_KEY_last_announce_result_camel: return TR_KEY_last_announce_result;
case TR_KEY_last_announce_start_time_camel: return TR_KEY_last_announce_start_time;
case TR_KEY_last_announce_succeeded_camel: return TR_KEY_last_announce_succeeded;
case TR_KEY_last_announce_time_camel: return TR_KEY_last_announce_time;
case TR_KEY_last_announce_timed_out_camel: return TR_KEY_last_announce_timed_out;
case TR_KEY_last_scrape_result_camel: return TR_KEY_last_scrape_result;
case TR_KEY_last_scrape_start_time_camel: return TR_KEY_last_scrape_start_time;
case TR_KEY_last_scrape_succeeded_camel: return TR_KEY_last_scrape_succeeded;
case TR_KEY_last_scrape_time_camel: return TR_KEY_last_scrape_time;
case TR_KEY_last_scrape_timed_out_camel: return TR_KEY_last_scrape_timed_out;
case TR_KEY_leecher_count_camel: return TR_KEY_leecher_count;
case TR_KEY_left_until_done_camel: return TR_KEY_left_until_done;
case TR_KEY_lpd_enabled_kebab: return TR_KEY_lpd_enabled;
case TR_KEY_magnet_link_camel: return TR_KEY_magnet_link;
case TR_KEY_main_window_height_kebab: return TR_KEY_main_window_height;
case TR_KEY_main_window_is_maximized_kebab: return TR_KEY_main_window_is_maximized;
case TR_KEY_main_window_layout_order_kebab: return TR_KEY_main_window_layout_order;
case TR_KEY_main_window_width_kebab: return TR_KEY_main_window_width;
case TR_KEY_main_window_x_kebab: return TR_KEY_main_window_x;
case TR_KEY_main_window_y_kebab: return TR_KEY_main_window_y;
case TR_KEY_manual_announce_time_camel: return TR_KEY_manual_announce_time;
case TR_KEY_max_connected_peers_camel: return TR_KEY_max_connected_peers;
case TR_KEY_max_peers_kebab: return TR_KEY_max_peers;
case TR_KEY_memory_bytes_kebab: return TR_KEY_memory_bytes;
case TR_KEY_memory_units_kebab: return TR_KEY_memory_units;
case TR_KEY_message_level_kebab: return TR_KEY_message_level;
case TR_KEY_metadata_percent_complete_camel: return TR_KEY_metadata_percent_complete;
case TR_KEY_next_announce_time_camel: return TR_KEY_next_announce_time;
case TR_KEY_next_scrape_time_camel: return TR_KEY_next_scrape_time;
case TR_KEY_open_dialog_dir_kebab: return TR_KEY_open_dialog_dir;
case TR_KEY_paused_torrent_count_camel: return TR_KEY_paused_torrent_count;
case TR_KEY_peer_congestion_algorithm_kebab: return TR_KEY_peer_congestion_algorithm;
case TR_KEY_peer_is_choked_camel: return TR_KEY_peer_is_choked;
case TR_KEY_peer_is_interested_camel: return TR_KEY_peer_is_interested;
case TR_KEY_peer_limit_kebab: return TR_KEY_peer_limit;
case TR_KEY_peer_limit_global_kebab: return TR_KEY_peer_limit_global;
case TR_KEY_peer_limit_per_torrent_kebab: return TR_KEY_peer_limit_per_torrent;
case TR_KEY_peer_port_kebab: return TR_KEY_peer_port;
case TR_KEY_peer_port_random_high_kebab: return TR_KEY_peer_port_random_high;
case TR_KEY_peer_port_random_low_kebab: return TR_KEY_peer_port_random_low;
case TR_KEY_peer_port_random_on_start_kebab: return TR_KEY_peer_port_random_on_start;
case TR_KEY_peer_socket_tos_kebab: return TR_KEY_peer_socket_tos;
case TR_KEY_peers2_6_kebab: return TR_KEY_peers2_6;
case TR_KEY_peers_connected_camel: return TR_KEY_peers_connected;
case TR_KEY_peers_from_camel: return TR_KEY_peers_from;
case TR_KEY_peers_getting_from_us_camel: return TR_KEY_peers_getting_from_us;
case TR_KEY_peers_sending_to_us_camel: return TR_KEY_peers_sending_to_us;
case TR_KEY_percent_complete_camel: return TR_KEY_percent_complete;
case TR_KEY_percent_done_camel: return TR_KEY_percent_done;
case TR_KEY_pex_enabled_kebab: return TR_KEY_pex_enabled;
case TR_KEY_piece_count_camel: return TR_KEY_piece_count;
case TR_KEY_piece_size_camel: return TR_KEY_piece_size;
case TR_KEY_port_forwarding_enabled_kebab: return TR_KEY_port_forwarding_enabled;
case TR_KEY_port_is_open_kebab: return TR_KEY_port_is_open;
case TR_KEY_primary_mime_type_kebab: return TR_KEY_primary_mime_type;
case TR_KEY_priority_high_kebab: return TR_KEY_priority_high;
case TR_KEY_priority_low_kebab: return TR_KEY_priority_low;
case TR_KEY_priority_normal_kebab: return TR_KEY_priority_normal;
case TR_KEY_prompt_before_exit_kebab: return TR_KEY_prompt_before_exit;
case TR_KEY_queue_position_camel: return TR_KEY_queue_position;
case TR_KEY_queue_stalled_enabled_kebab: return TR_KEY_queue_stalled_enabled;
case TR_KEY_queue_stalled_minutes_kebab: return TR_KEY_queue_stalled_minutes;
case TR_KEY_rate_download_camel: return TR_KEY_rate_download;
case TR_KEY_rate_to_client_camel: return TR_KEY_rate_to_client;
case TR_KEY_rate_to_peer_camel: return TR_KEY_rate_to_peer;
case TR_KEY_rate_upload_camel: return TR_KEY_rate_upload;
case TR_KEY_ratio_limit_kebab: return TR_KEY_ratio_limit;
case TR_KEY_ratio_limit_enabled_kebab: return TR_KEY_ratio_limit_enabled;
case TR_KEY_ratio_mode_kebab: return TR_KEY_ratio_mode;
case TR_KEY_read_clipboard_kebab: return TR_KEY_read_clipboard;
case TR_KEY_recheck_progress_camel: return TR_KEY_recheck_progress;
case TR_KEY_remote_session_enabled_kebab: return TR_KEY_remote_session_enabled;
case TR_KEY_remote_session_host_kebab: return TR_KEY_remote_session_host;
case TR_KEY_remote_session_https_kebab: return TR_KEY_remote_session_https;
case TR_KEY_remote_session_password_kebab: return TR_KEY_remote_session_password;
case TR_KEY_remote_session_port_kebab: return TR_KEY_remote_session_port;
case TR_KEY_remote_session_requres_authentication_kebab: return TR_KEY_remote_session_requires_authentication;
case TR_KEY_remote_session_username_kebab: return TR_KEY_remote_session_username;
case TR_KEY_rename_partial_files_kebab: return TR_KEY_rename_partial_files;
case TR_KEY_rpc_authentication_required_kebab: return TR_KEY_rpc_authentication_required;
case TR_KEY_rpc_bind_address_kebab: return TR_KEY_rpc_bind_address;
case TR_KEY_rpc_enabled_kebab: return TR_KEY_rpc_enabled;
case TR_KEY_rpc_host_whitelist_kebab: return TR_KEY_rpc_host_whitelist;
case TR_KEY_rpc_host_whitelist_enabled_kebab: return TR_KEY_rpc_host_whitelist_enabled;
case TR_KEY_rpc_password_kebab: return TR_KEY_rpc_password;
case TR_KEY_rpc_port_kebab: return TR_KEY_rpc_port;
case TR_KEY_rpc_socket_mode_kebab: return TR_KEY_rpc_socket_mode;
case TR_KEY_rpc_url_kebab: return TR_KEY_rpc_url;
case TR_KEY_rpc_username_kebab: return TR_KEY_rpc_username;
case TR_KEY_rpc_version_kebab: return TR_KEY_rpc_version;
case TR_KEY_rpc_version_minimum_kebab: return TR_KEY_rpc_version_minimum;
case TR_KEY_rpc_version_semver_kebab: return TR_KEY_rpc_version_semver;
case TR_KEY_rpc_whitelist_kebab: return TR_KEY_rpc_whitelist;
case TR_KEY_rpc_whitelist_enabled_kebab: return TR_KEY_rpc_whitelist_enabled;
case TR_KEY_seconds_downloading_camel: return TR_KEY_seconds_downloading;
case TR_KEY_scrape_paused_torrents_enabled_kebab: return TR_KEY_scrape_paused_torrents_enabled;
case TR_KEY_scrape_state_camel: return TR_KEY_scrape_state;
case TR_KEY_script_torrent_added_enabled_kebab: return TR_KEY_script_torrent_added_enabled;
case TR_KEY_script_torrent_added_filename_kebab: return TR_KEY_script_torrent_added_filename;
case TR_KEY_script_torrent_done_enabled_kebab: return TR_KEY_script_torrent_done_enabled;
case TR_KEY_script_torrent_done_filename_kebab: return TR_KEY_script_torrent_done_filename;
case TR_KEY_script_torrent_done_seeding_enabled_kebab: return TR_KEY_script_torrent_done_seeding_enabled;
case TR_KEY_script_torrent_done_seeding_filename_kebab: return TR_KEY_script_torrent_done_seeding_filename;
case TR_KEY_seconds_active_camel:
case TR_KEY_seconds_active_kebab:
return TR_KEY_seconds_active;
case TR_KEY_seconds_seeding_camel: return TR_KEY_seconds_seeding;
case TR_KEY_seed_idle_limit_camel: return TR_KEY_seed_idle_limit;
case TR_KEY_seed_idle_mode_camel: return TR_KEY_seed_idle_mode;
case TR_KEY_seed_queue_enabled_kebab: return TR_KEY_seed_queue_enabled;
case TR_KEY_seed_queue_size_kebab: return TR_KEY_seed_queue_size;
case TR_KEY_seed_ratio_limit_camel: return TR_KEY_seed_ratio_limit;
case TR_KEY_seed_ratio_limited_camel: return TR_KEY_seed_ratio_limited;
case TR_KEY_seed_ratio_mode_camel: return TR_KEY_seed_ratio_mode;
case TR_KEY_seeding_time_seconds_kebab: return TR_KEY_seeding_time_seconds;
case TR_KEY_seeder_count_camel: return TR_KEY_seeder_count;
case TR_KEY_session_count_camel:
case TR_KEY_session_count_kebab:
return TR_KEY_session_count;
case TR_KEY_session_id_kebab: return TR_KEY_session_id;
case TR_KEY_show_backup_trackers_kebab: return TR_KEY_show_backup_trackers;
case TR_KEY_show_extra_peer_details_kebab: return TR_KEY_show_extra_peer_details;
case TR_KEY_show_filterbar_kebab: return TR_KEY_show_filterbar;
case TR_KEY_show_notification_area_icon_kebab: return TR_KEY_show_notification_area_icon;
case TR_KEY_show_options_window_kebab: return TR_KEY_show_options_window;
case TR_KEY_show_statusbar_kebab: return TR_KEY_show_statusbar;
case TR_KEY_show_toolbar_kebab: return TR_KEY_show_toolbar;
case TR_KEY_show_tracker_scrapes_kebab: return TR_KEY_show_tracker_scrapes;
case TR_KEY_size_bytes_kebab: return TR_KEY_size_bytes;
case TR_KEY_size_units_kebab: return TR_KEY_size_units;
case TR_KEY_size_when_done_camel: return TR_KEY_size_when_done;
case TR_KEY_sort_mode_kebab: return TR_KEY_sort_mode;
case TR_KEY_sort_reversed_kebab: return TR_KEY_sort_reversed;
case TR_KEY_speed_Bps_kebab: return TR_KEY_speed_Bps;
case TR_KEY_speed_bytes_kebab: return TR_KEY_speed_bytes;
case TR_KEY_speed_limit_down_kebab: return TR_KEY_speed_limit_down;
case TR_KEY_speed_limit_down_enabled_kebab: return TR_KEY_speed_limit_down_enabled;
case TR_KEY_speed_limit_up_kebab: return TR_KEY_speed_limit_up;
case TR_KEY_speed_limit_up_enabled_kebab: return TR_KEY_speed_limit_up_enabled;
case TR_KEY_speed_units_kebab: return TR_KEY_speed_units;
case TR_KEY_start_added_torrents_kebab: return TR_KEY_start_added_torrents;
case TR_KEY_start_date_camel: return TR_KEY_start_date;
case TR_KEY_start_minimized_kebab: return TR_KEY_start_minimized;
case TR_KEY_statusbar_stats_kebab: return TR_KEY_statusbar_stats;
case TR_KEY_tcp_enabled_kebab: return TR_KEY_tcp_enabled;
case TR_KEY_torrent_added_kebab: return TR_KEY_torrent_added;
case TR_KEY_torrent_added_notification_enabled_kebab: return TR_KEY_torrent_added_notification_enabled;
case TR_KEY_torrent_added_verify_mode_kebab: return TR_KEY_torrent_added_verify_mode;
case TR_KEY_torrent_complete_notification_enabled_kebab: return TR_KEY_torrent_complete_notification_enabled;
case TR_KEY_torrent_complete_sound_command_kebab: return TR_KEY_torrent_complete_sound_command;
case TR_KEY_torrent_complete_sound_enabled_kebab: return TR_KEY_torrent_complete_sound_enabled;
case TR_KEY_torrent_count_camel: return TR_KEY_torrent_count;
case TR_KEY_torrent_duplicate_kebab: return TR_KEY_torrent_duplicate;
case TR_KEY_torrent_file_camel: return TR_KEY_torrent_file;
case TR_KEY_torrent_get_kebab: return TR_KEY_torrent_get;
case TR_KEY_torrent_set_kebab: return TR_KEY_torrent_set;
case TR_KEY_torrent_set_location_kebab: return TR_KEY_torrent_set_location;
case TR_KEY_total_size_camel: return TR_KEY_total_size;
case TR_KEY_tracker_add_camel: return TR_KEY_tracker_add;
case TR_KEY_tracker_list_camel: return TR_KEY_tracker_list;
case TR_KEY_tracker_remove_camel: return TR_KEY_tracker_remove;
case TR_KEY_tracker_replace_camel: return TR_KEY_tracker_replace;
case TR_KEY_tracker_stats_camel: return TR_KEY_tracker_stats;
case TR_KEY_trash_can_enabled_kebab: return TR_KEY_trash_can_enabled;
case TR_KEY_trash_original_torrent_files_kebab: return TR_KEY_trash_original_torrent_files;
case TR_KEY_upload_limit_camel: return TR_KEY_upload_limit;
case TR_KEY_upload_limited_camel: return TR_KEY_upload_limited;
case TR_KEY_upload_slots_per_torrent_kebab: return TR_KEY_upload_slots_per_torrent;
case TR_KEY_upload_ratio_camel: return TR_KEY_upload_ratio;
case TR_KEY_upload_speed_camel: return TR_KEY_upload_speed;
case TR_KEY_uploaded_bytes_camel:
case TR_KEY_uploaded_bytes_kebab:
return TR_KEY_uploaded_bytes;
case TR_KEY_uploaded_ever_camel: return TR_KEY_uploaded_ever;
case TR_KEY_use_global_speed_limit_kebab: return TR_KEY_use_global_speed_limit;
case TR_KEY_use_speed_limit_kebab: return TR_KEY_use_speed_limit;
case TR_KEY_user_has_given_informed_consent_kebab: return TR_KEY_user_has_given_informed_consent;
case TR_KEY_utp_enabled_kebab: return TR_KEY_utp_enabled;
case TR_KEY_watch_dir_kebab: return TR_KEY_watch_dir;
case TR_KEY_watch_dir_enabled_kebab: return TR_KEY_watch_dir_enabled;
case TR_KEY_watch_dir_force_generic_kebab: return TR_KEY_watch_dir_force_generic;
case TR_KEY_webseeds_sending_to_us_camel: return TR_KEY_webseeds_sending_to_us;
default: return q;
}
// clang-format on
}

530
libtransmission/quark.h
View File

@@ -14,24 +14,30 @@ using tr_quark = size_t;
/*
* Predefined Quarks.
*
* TODO: it would be nice to clean up all the naming inconsistencies
* between RPC and settings. This will be a mess and we shouldn't be
* in a hurry to do it.
*/
enum // NOLINT(performance-enum-size)
{
TR_KEY_NONE, /* represented as an empty string */
TR_KEY_activeTorrentCount, /* rpc */
TR_KEY_activity_date, /* resume file */
TR_KEY_activityDate, /* rpc */
TR_KEY_active_torrent_count_camel, /* rpc (deprecated) */
TR_KEY_active_torrent_count, /* rpc */
TR_KEY_activity_date_kebab, /* resume file (legacy) */
TR_KEY_activity_date_camel, /* rpc (deprecated) */
TR_KEY_activity_date, /* rpc, resume file */
TR_KEY_added, /* pex */
TR_KEY_added_date, /* rpc */
TR_KEY_added_date_kebab, /* resume file (legacy) */
TR_KEY_added_f, /* pex */
TR_KEY_added6, /* pex */
TR_KEY_added6_f, /* pex */
TR_KEY_addedDate, /* rpc */
TR_KEY_added_date_camel, /* rpc (deprecated) */
TR_KEY_added_date, /* rpc, resume file */
TR_KEY_address, /* rpc */
TR_KEY_alt_speed_down_kebab, /* rpc, settings (deprecated) */
TR_KEY_alt_speed_enabled_kebab, /* rpc, settings (deprecated) */
TR_KEY_alt_speed_time_begin_kebab, /* rpc, settings (deprecated) */
TR_KEY_alt_speed_time_day_kebab, /* rpc, settings (deprecated) */
TR_KEY_alt_speed_time_enabled_kebab, /* rpc, settings (deprecated) */
TR_KEY_alt_speed_time_end_kebab, /* rpc, settings (deprecated) */
TR_KEY_alt_speed_up_kebab, /* rpc, settings (deprecated) */
TR_KEY_alt_speed_down, /* rpc, settings */
TR_KEY_alt_speed_enabled, /* rpc, settings */
TR_KEY_alt_speed_time_begin, /* rpc, settings */
@@ -40,174 +46,285 @@ enum // NOLINT(performance-enum-size)
TR_KEY_alt_speed_time_end, /* rpc, settings */
TR_KEY_alt_speed_up, /* rpc, settings */
TR_KEY_announce, /* metainfo */
TR_KEY_announce_ip, /* metainfo, settings */
TR_KEY_announce_ip_enabled, /* metainfo, settings */
TR_KEY_announce_ip_kebab, /* settings (legacy) */
TR_KEY_announce_ip_enabled_kebab, /* settings (legacy) */
TR_KEY_announce_list, /* metainfo */
TR_KEY_announceState, /* rpc */
TR_KEY_anti_brute_force_enabled, /* rpc */
TR_KEY_anti_brute_force_threshold, /* rpc */
TR_KEY_announce_state_camel, /* rpc (deprecated) */
TR_KEY_announce_ip, /* settings */
TR_KEY_announce_ip_enabled, /* settings */
TR_KEY_announce_state, /* rpc */
TR_KEY_anti_brute_force_enabled_kebab, /* rpc, settings (deprecated) */
TR_KEY_anti_brute_force_threshold_kebab, /* rpc, settings (deprecated) */
TR_KEY_anti_brute_force_enabled, /* rpc, settings */
TR_KEY_anti_brute_force_threshold, /* rpc, settings */
TR_KEY_arguments, /* rpc */
TR_KEY_availability, // rpc
TR_KEY_bandwidth_priority_kebab,
TR_KEY_bandwidth_priority_camel,
TR_KEY_bandwidth_priority,
TR_KEY_bandwidthPriority,
TR_KEY_begin_piece,
TR_KEY_bind_address_ipv4_kebab,
TR_KEY_bind_address_ipv6_kebab,
TR_KEY_bind_address_ipv4,
TR_KEY_bind_address_ipv6,
TR_KEY_bitfield,
TR_KEY_blocklist_date_kebab,
TR_KEY_blocklist_enabled_kebab,
TR_KEY_blocklist_size_kebab,
TR_KEY_blocklist_updates_enabled_kebab,
TR_KEY_blocklist_url_kebab,
TR_KEY_blocklist_date,
TR_KEY_blocklist_enabled,
TR_KEY_blocklist_size,
TR_KEY_blocklist_updates_enabled,
TR_KEY_blocklist_url,
TR_KEY_blocks,
TR_KEY_bytesCompleted,
TR_KEY_bytes_completed_camel,
TR_KEY_bytes_completed,
TR_KEY_bytes_to_client,
TR_KEY_bytes_to_peer,
TR_KEY_cache_size_mb_kebab,
TR_KEY_cache_size_mb,
TR_KEY_clientIsChoked,
TR_KEY_clientIsInterested,
TR_KEY_clientName,
TR_KEY_client_is_choked_camel,
TR_KEY_client_is_interested_camel,
TR_KEY_client_name_camel,
TR_KEY_client_is_choked,
TR_KEY_client_is_interested,
TR_KEY_client_name,
TR_KEY_code,
TR_KEY_comment,
TR_KEY_compact_view_kebab,
TR_KEY_compact_view,
TR_KEY_complete,
TR_KEY_config_dir_kebab,
TR_KEY_config_dir,
TR_KEY_cookies,
TR_KEY_corrupt,
TR_KEY_corruptEver,
TR_KEY_corrupt_ever_camel,
TR_KEY_corrupt_ever,
TR_KEY_created_by,
TR_KEY_creation_date,
TR_KEY_creator,
TR_KEY_cumulative_stats_kebab,
TR_KEY_cumulative_stats,
TR_KEY_current_stats_kebab,
TR_KEY_current_stats,
TR_KEY_data,
TR_KEY_date,
TR_KEY_dateCreated,
TR_KEY_date_created_camel,
TR_KEY_date_created,
TR_KEY_default_trackers_kebab,
TR_KEY_default_trackers,
TR_KEY_delete_local_data_kebab,
TR_KEY_delete_local_data,
TR_KEY_desiredAvailable,
TR_KEY_desired_available_camel,
TR_KEY_desired_available,
TR_KEY_destination,
TR_KEY_details_window_height_kebab,
TR_KEY_details_window_width_kebab,
TR_KEY_details_window_height,
TR_KEY_details_window_width,
TR_KEY_dht_enabled_kebab,
TR_KEY_dht_enabled,
TR_KEY_dnd,
TR_KEY_done_date_kebab,
TR_KEY_done_date_camel,
TR_KEY_done_date,
TR_KEY_doneDate,
TR_KEY_download_dir_kebab,
TR_KEY_download_dir_free_space_kebab,
TR_KEY_download_queue_enabled_kebab,
TR_KEY_download_queue_size_kebab,
TR_KEY_download_count_camel,
TR_KEY_download_dir_camel,
TR_KEY_download_limit_camel,
TR_KEY_download_limited_camel,
TR_KEY_download_speed_camel,
TR_KEY_download_count,
TR_KEY_download_dir,
TR_KEY_download_dir_free_space,
TR_KEY_download_limit,
TR_KEY_download_limited,
TR_KEY_download_queue_enabled,
TR_KEY_download_queue_size,
TR_KEY_downloadCount,
TR_KEY_downloadDir,
TR_KEY_downloadLimit,
TR_KEY_downloadLimited,
TR_KEY_downloadSpeed,
TR_KEY_download_speed,
TR_KEY_downloaded,
TR_KEY_downloaded_bytes_kebab,
TR_KEY_downloaded_bytes_camel,
TR_KEY_downloaded_ever_camel,
TR_KEY_downloaded_bytes,
TR_KEY_downloadedBytes,
TR_KEY_downloadedEver,
TR_KEY_downloaded_ever,
TR_KEY_downloader_count,
TR_KEY_downloading_time_seconds_kebab,
TR_KEY_downloading_time_seconds,
TR_KEY_dropped,
TR_KEY_dropped6,
TR_KEY_e,
TR_KEY_editDate,
TR_KEY_edit_date_camel,
TR_KEY_edit_date,
TR_KEY_encoding,
TR_KEY_encryption,
TR_KEY_end_piece,
TR_KEY_error,
TR_KEY_errorString,
TR_KEY_error_string_camel,
TR_KEY_error_string,
TR_KEY_eta,
TR_KEY_etaIdle,
TR_KEY_eta_idle_camel,
TR_KEY_eta_idle,
TR_KEY_fields,
TR_KEY_file_count_kebab,
TR_KEY_file_stats_camel,
TR_KEY_file_count,
TR_KEY_fileStats,
TR_KEY_file_stats,
TR_KEY_filename,
TR_KEY_files,
TR_KEY_files_added_kebab,
TR_KEY_files_unwanted_kebab,
TR_KEY_files_wanted_kebab,
TR_KEY_files_added_camel,
TR_KEY_files_added,
TR_KEY_files_unwanted,
TR_KEY_files_wanted,
TR_KEY_filesAdded,
TR_KEY_filter_mode_kebab,
TR_KEY_filter_text_kebab,
TR_KEY_filter_trackers_kebab,
TR_KEY_filter_mode,
TR_KEY_filter_text,
TR_KEY_filter_trackers,
TR_KEY_flagStr,
TR_KEY_flag_str_camel,
TR_KEY_flag_str,
TR_KEY_flags,
TR_KEY_format,
TR_KEY_fromCache,
TR_KEY_fromDht,
TR_KEY_fromIncoming,
TR_KEY_fromLpd,
TR_KEY_fromLtep,
TR_KEY_fromPex,
TR_KEY_fromTracker,
TR_KEY_from_cache_camel,
TR_KEY_from_dht_camel,
TR_KEY_from_incoming_camel,
TR_KEY_from_lpd_camel,
TR_KEY_from_ltep_camel,
TR_KEY_from_pex_camel,
TR_KEY_from_tracker_camel,
TR_KEY_from_cache,
TR_KEY_from_dht,
TR_KEY_from_incoming,
TR_KEY_from_lpd,
TR_KEY_from_ltep,
TR_KEY_from_pex,
TR_KEY_from_tracker,
TR_KEY_group,
TR_KEY_hasAnnounced,
TR_KEY_hasScraped,
TR_KEY_hashString,
TR_KEY_has_announced_camel,
TR_KEY_has_scraped_camel,
TR_KEY_has_announced,
TR_KEY_has_scraped,
TR_KEY_hash_string_camel,
TR_KEY_hash_string,
TR_KEY_have,
TR_KEY_haveUnchecked,
TR_KEY_haveValid,
TR_KEY_honorsSessionLimits,
TR_KEY_have_unchecked_camel,
TR_KEY_have_valid_camel,
TR_KEY_have_unchecked,
TR_KEY_have_valid,
TR_KEY_honors_session_limits_camel,
TR_KEY_honors_session_limits,
TR_KEY_host,
TR_KEY_id,
TR_KEY_id_timestamp,
TR_KEY_idle_limit_kebab,
TR_KEY_idle_mode_kebab,
TR_KEY_idle_seeding_limit_kebab,
TR_KEY_idle_seeding_limit_enabled_kebab,
TR_KEY_idle_limit,
TR_KEY_idle_mode,
TR_KEY_idle_seeding_limit,
TR_KEY_idle_seeding_limit_enabled,
TR_KEY_ids,
TR_KEY_incomplete,
TR_KEY_incomplete_dir_kebab,
TR_KEY_incomplete_dir_enabled_kebab,
TR_KEY_incomplete_dir,
TR_KEY_incomplete_dir_enabled,
TR_KEY_info,
TR_KEY_inhibit_desktop_hibernation_kebab,
TR_KEY_inhibit_desktop_hibernation,
TR_KEY_ip_protocol,
TR_KEY_ipv4,
TR_KEY_ipv6,
TR_KEY_isBackup,
TR_KEY_isDownloadingFrom,
TR_KEY_isEncrypted,
TR_KEY_isFinished,
TR_KEY_isIncoming,
TR_KEY_isPrivate,
TR_KEY_isStalled,
TR_KEY_isUTP,
TR_KEY_isUploadingTo,
TR_KEY_is_backup_camel,
TR_KEY_is_downloading_from_camel,
TR_KEY_is_encrypted_camel,
TR_KEY_is_finished_camel,
TR_KEY_is_incoming_camel,
TR_KEY_is_private_camel,
TR_KEY_is_stalled_camel,
TR_KEY_is_utp_camel,
TR_KEY_is_uploading_to_camel,
TR_KEY_is_backup,
TR_KEY_is_downloading_from,
TR_KEY_is_encrypted,
TR_KEY_is_finished,
TR_KEY_is_incoming,
TR_KEY_is_private,
TR_KEY_is_stalled,
TR_KEY_is_uploading_to,
TR_KEY_is_utp,
TR_KEY_jsonrpc,
TR_KEY_labels,
TR_KEY_lastAnnouncePeerCount,
TR_KEY_lastAnnounceResult,
TR_KEY_lastAnnounceStartTime,
TR_KEY_lastAnnounceSucceeded,
TR_KEY_lastAnnounceTime,
TR_KEY_lastAnnounceTimedOut,
TR_KEY_lastScrapeResult,
TR_KEY_lastScrapeStartTime,
TR_KEY_lastScrapeSucceeded,
TR_KEY_lastScrapeTime,
TR_KEY_lastScrapeTimedOut,
TR_KEY_leecherCount,
TR_KEY_leftUntilDone,
TR_KEY_last_announce_peer_count_camel,
TR_KEY_last_announce_result_camel,
TR_KEY_last_announce_start_time_camel,
TR_KEY_last_announce_succeeded_camel,
TR_KEY_last_announce_time_camel,
TR_KEY_last_announce_timed_out_camel,
TR_KEY_last_scrape_result_camel,
TR_KEY_last_scrape_start_time_camel,
TR_KEY_last_scrape_succeeded_camel,
TR_KEY_last_scrape_time_camel,
TR_KEY_last_scrape_timed_out_camel,
TR_KEY_last_announce_peer_count,
TR_KEY_last_announce_result,
TR_KEY_last_announce_start_time,
TR_KEY_last_announce_succeeded,
TR_KEY_last_announce_time,
TR_KEY_last_announce_timed_out,
TR_KEY_last_scrape_result,
TR_KEY_last_scrape_start_time,
TR_KEY_last_scrape_succeeded,
TR_KEY_last_scrape_time,
TR_KEY_last_scrape_timed_out,
TR_KEY_leecher_count_camel,
TR_KEY_leecher_count,
TR_KEY_left_until_done_camel,
TR_KEY_left_until_done,
TR_KEY_length,
TR_KEY_location,
TR_KEY_lpd_enabled_kebab,
TR_KEY_lpd_enabled,
TR_KEY_m,
TR_KEY_magnetLink,
TR_KEY_magnet_link_camel,
TR_KEY_magnet_link,
TR_KEY_main_window_height_kebab,
TR_KEY_main_window_is_maximized_kebab,
TR_KEY_main_window_layout_order_kebab,
TR_KEY_main_window_width_kebab,
TR_KEY_main_window_x_kebab,
TR_KEY_main_window_y_kebab,
TR_KEY_main_window_height,
TR_KEY_main_window_is_maximized,
TR_KEY_main_window_layout_order,
TR_KEY_main_window_width,
TR_KEY_main_window_x,
TR_KEY_main_window_y,
TR_KEY_manualAnnounceTime,
TR_KEY_manual_announce_time_camel,
TR_KEY_manual_announce_time,
TR_KEY_max_peers_kebab,
TR_KEY_max_connected_peers_camel,
TR_KEY_max_connected_peers,
TR_KEY_max_peers,
TR_KEY_maxConnectedPeers,
TR_KEY_memory_bytes_kebab,
TR_KEY_memory_units_kebab,
TR_KEY_memory_bytes,
TR_KEY_memory_units,
TR_KEY_message,
TR_KEY_message_level_kebab,
TR_KEY_message_level,
TR_KEY_metadataPercentComplete,
TR_KEY_metadata_percent_complete_camel,
TR_KEY_metadata_percent_complete,
TR_KEY_metadata_size,
TR_KEY_metainfo,
TR_KEY_method,
@@ -215,17 +332,35 @@ enum // NOLINT(performance-enum-size)
TR_KEY_msg_type,
TR_KEY_mtimes,
TR_KEY_name,
TR_KEY_nextAnnounceTime,
TR_KEY_nextScrapeTime,
TR_KEY_next_announce_time_camel,
TR_KEY_next_scrape_time_camel,
TR_KEY_next_announce_time,
TR_KEY_next_scrape_time,
TR_KEY_nodes,
TR_KEY_nodes6,
TR_KEY_open_dialog_dir_kebab,
TR_KEY_open_dialog_dir,
TR_KEY_p,
TR_KEY_params,
TR_KEY_path,
TR_KEY_paused,
TR_KEY_pausedTorrentCount,
TR_KEY_paused_torrent_count_camel,
TR_KEY_paused_torrent_count,
TR_KEY_peer_congestion_algorithm_kebab,
TR_KEY_peer_limit_kebab,
TR_KEY_peer_limit_global_kebab,
TR_KEY_peer_limit_per_torrent_kebab,
TR_KEY_peer_port_kebab,
TR_KEY_peer_port_random_high_kebab,
TR_KEY_peer_port_random_low_kebab,
TR_KEY_peer_port_random_on_start_kebab,
TR_KEY_peer_socket_tos_kebab,
TR_KEY_peer_is_choked_camel,
TR_KEY_peer_is_interested_camel,
TR_KEY_peer_congestion_algorithm,
TR_KEY_peer_id,
TR_KEY_peer_is_choked,
TR_KEY_peer_is_interested,
TR_KEY_peer_limit,
TR_KEY_peer_limit_global,
TR_KEY_peer_limit_per_torrent,
@@ -234,64 +369,113 @@ enum // NOLINT(performance-enum-size)
TR_KEY_peer_port_random_low,
TR_KEY_peer_port_random_on_start,
TR_KEY_peer_socket_tos,
TR_KEY_peerIsChoked,
TR_KEY_peerIsInterested,
TR_KEY_peer_id,
TR_KEY_peers,
TR_KEY_peers2,
TR_KEY_peers2_6_kebab,
TR_KEY_peers2_6,
TR_KEY_peersConnected,
TR_KEY_peersFrom,
TR_KEY_peersGettingFromUs,
TR_KEY_peersSendingToUs,
TR_KEY_percentComplete,
TR_KEY_percentDone,
TR_KEY_peers_connected_camel,
TR_KEY_peers_from_camel,
TR_KEY_peers_getting_from_us_camel,
TR_KEY_peers_sending_to_us_camel,
TR_KEY_peers_connected,
TR_KEY_peers_from,
TR_KEY_peers_getting_from_us,
TR_KEY_peers_sending_to_us,
TR_KEY_percent_complete_camel,
TR_KEY_percent_done_camel,
TR_KEY_percent_complete,
TR_KEY_percent_done,
TR_KEY_pex_enabled_kebab,
TR_KEY_pex_enabled,
TR_KEY_pidfile,
TR_KEY_piece,
TR_KEY_piece_length,
TR_KEY_pieceCount,
TR_KEY_pieceSize,
TR_KEY_piece_count_camel,
TR_KEY_piece_size_camel,
TR_KEY_piece_count,
TR_KEY_piece_size,
TR_KEY_pieces,
TR_KEY_port,
TR_KEY_port_forwarding_enabled_kebab,
TR_KEY_port_is_open_kebab,
TR_KEY_port_forwarding_enabled,
TR_KEY_port_is_open,
TR_KEY_preallocation,
TR_KEY_preferred_transports,
TR_KEY_primary_mime_type_kebab,
TR_KEY_primary_mime_type,
TR_KEY_priorities,
TR_KEY_priority,
TR_KEY_priority_high_kebab,
TR_KEY_priority_low_kebab,
TR_KEY_priority_normal_kebab,
TR_KEY_priority_high,
TR_KEY_priority_low,
TR_KEY_priority_normal,
TR_KEY_private,
TR_KEY_progress,
TR_KEY_prompt_before_exit_kebab,
TR_KEY_prompt_before_exit,
TR_KEY_proxy_url,
TR_KEY_queue_stalled_enabled_kebab,
TR_KEY_queue_stalled_minutes_kebab,
TR_KEY_queue_position_camel,
TR_KEY_queue_position,
TR_KEY_queue_stalled_enabled,
TR_KEY_queue_stalled_minutes,
TR_KEY_queuePosition,
TR_KEY_rateDownload,
TR_KEY_rateToClient,
TR_KEY_rateToPeer,
TR_KEY_rateUpload,
TR_KEY_rate_download_camel,
TR_KEY_rate_to_client_camel,
TR_KEY_rate_to_peer_camel,
TR_KEY_rate_upload_camel,
TR_KEY_rate_download,
TR_KEY_rate_to_client,
TR_KEY_rate_to_peer,
TR_KEY_rate_upload,
TR_KEY_ratio_limit_kebab,
TR_KEY_ratio_limit_enabled_kebab,
TR_KEY_ratio_mode_kebab,
TR_KEY_ratio_limit,
TR_KEY_ratio_limit_enabled,
TR_KEY_ratio_mode,
TR_KEY_read_clipboard_kebab,
TR_KEY_read_clipboard,
TR_KEY_recheckProgress,
TR_KEY_recheck_progress_camel,
TR_KEY_recheck_progress,
TR_KEY_remote_session_enabled_kebab,
TR_KEY_remote_session_host_kebab,
TR_KEY_remote_session_https_kebab,
TR_KEY_remote_session_password_kebab,
TR_KEY_remote_session_port_kebab,
TR_KEY_remote_session_requres_authentication_kebab,
TR_KEY_remote_session_username_kebab,
TR_KEY_remote_session_enabled,
TR_KEY_remote_session_host,
TR_KEY_remote_session_https,
TR_KEY_remote_session_password,
TR_KEY_remote_session_port,
TR_KEY_remote_session_requres_authentication,
TR_KEY_remote_session_username,
TR_KEY_remote_session_requires_authentication,
TR_KEY_remote_session_rpc_url_path,
TR_KEY_remote_session_username,
TR_KEY_removed,
TR_KEY_rename_partial_files_kebab,
TR_KEY_rename_partial_files,
TR_KEY_reqq,
TR_KEY_result,
TR_KEY_rpc_authentication_required_kebab,
TR_KEY_rpc_bind_address_kebab,
TR_KEY_rpc_enabled_kebab,
TR_KEY_rpc_host_whitelist_kebab,
TR_KEY_rpc_host_whitelist_enabled_kebab,
TR_KEY_rpc_password_kebab,
TR_KEY_rpc_port_kebab,
TR_KEY_rpc_socket_mode_kebab,
TR_KEY_rpc_url_kebab,
TR_KEY_rpc_username_kebab,
TR_KEY_rpc_version_kebab,
TR_KEY_rpc_version_minimum_kebab,
TR_KEY_rpc_version_semver_kebab,
TR_KEY_rpc_whitelist_kebab,
TR_KEY_rpc_whitelist_enabled_kebab,
TR_KEY_rpc_authentication_required,
TR_KEY_rpc_bind_address,
TR_KEY_rpc_enabled,
@@ -308,32 +492,62 @@ enum // NOLINT(performance-enum-size)
TR_KEY_rpc_whitelist,
TR_KEY_rpc_whitelist_enabled,
TR_KEY_scrape,
TR_KEY_scrape_paused_torrents_enabled_kebab,
TR_KEY_scrape_state_camel,
TR_KEY_scrape_paused_torrents_enabled,
TR_KEY_scrapeState,
TR_KEY_scrape_state,
TR_KEY_script_torrent_added_enabled_kebab,
TR_KEY_script_torrent_added_filename_kebab,
TR_KEY_script_torrent_done_enabled_kebab,
TR_KEY_script_torrent_done_filename_kebab,
TR_KEY_script_torrent_done_seeding_enabled_kebab,
TR_KEY_script_torrent_done_seeding_filename_kebab,
TR_KEY_script_torrent_added_enabled,
TR_KEY_script_torrent_added_filename,
TR_KEY_script_torrent_done_enabled,
TR_KEY_script_torrent_done_filename,
TR_KEY_script_torrent_done_seeding_enabled,
TR_KEY_script_torrent_done_seeding_filename,
TR_KEY_seconds_active_kebab,
TR_KEY_seconds_active_camel,
TR_KEY_seconds_downloading_camel,
TR_KEY_seconds_seeding_camel,
TR_KEY_seconds_active,
TR_KEY_secondsActive,
TR_KEY_secondsDownloading,
TR_KEY_secondsSeeding,
TR_KEY_seconds_downloading,
TR_KEY_seconds_seeding,
TR_KEY_seed_queue_enabled_kebab,
TR_KEY_seed_queue_size_kebab,
TR_KEY_seed_idle_limit_camel,
TR_KEY_seed_idle_mode_camel,
TR_KEY_seed_ratio_limit_camel,
TR_KEY_seed_ratio_limited_camel,
TR_KEY_seed_ratio_mode_camel,
TR_KEY_seed_idle_limit,
TR_KEY_seed_idle_mode,
TR_KEY_seed_queue_enabled,
TR_KEY_seed_queue_size,
TR_KEY_seedIdleLimit,
TR_KEY_seedIdleMode,
TR_KEY_seedRatioLimit,
TR_KEY_seedRatioLimited,
TR_KEY_seedRatioMode,
TR_KEY_seederCount,
TR_KEY_seed_ratio_limit,
TR_KEY_seed_ratio_limited,
TR_KEY_seed_ratio_mode,
TR_KEY_seeder_count_camel,
TR_KEY_seeder_count,
TR_KEY_seeding_time_seconds_kebab,
TR_KEY_seeding_time_seconds,
TR_KEY_sequential_download,
TR_KEY_sequential_download_from_piece,
TR_KEY_session_count_kebab,
TR_KEY_session_id_kebab,
TR_KEY_session_count_camel,
TR_KEY_session_count,
TR_KEY_session_id,
TR_KEY_sessionCount,
TR_KEY_show_backup_trackers_kebab,
TR_KEY_show_extra_peer_details_kebab,
TR_KEY_show_filterbar_kebab,
TR_KEY_show_notification_area_icon_kebab,
TR_KEY_show_options_window_kebab,
TR_KEY_show_statusbar_kebab,
TR_KEY_show_toolbar_kebab,
TR_KEY_show_tracker_scrapes_kebab,
TR_KEY_show_backup_trackers,
TR_KEY_show_extra_peer_details,
TR_KEY_show_filterbar,
@@ -343,15 +557,27 @@ enum // NOLINT(performance-enum-size)
TR_KEY_show_toolbar,
TR_KEY_show_tracker_scrapes,
TR_KEY_sitename,
TR_KEY_size_bytes_kebab,
TR_KEY_size_units_kebab,
TR_KEY_size_when_done_camel,
TR_KEY_size_bytes,
TR_KEY_size_units,
TR_KEY_sizeWhenDone,
TR_KEY_size_when_done,
TR_KEY_sleep_per_seconds_during_verify,
TR_KEY_socket_address,
TR_KEY_sort_mode_kebab,
TR_KEY_sort_reversed_kebab,
TR_KEY_sort_mode,
TR_KEY_sort_reversed,
TR_KEY_source,
TR_KEY_speed,
TR_KEY_speed_Bps_kebab,
TR_KEY_speed_bytes_kebab,
TR_KEY_speed_limit_down_kebab,
TR_KEY_speed_limit_down_enabled_kebab,
TR_KEY_speed_limit_up_kebab,
TR_KEY_speed_limit_up_enabled_kebab,
TR_KEY_speed_units_kebab,
TR_KEY_speed_Bps,
TR_KEY_speed_bytes,
TR_KEY_speed_limit_down,
@@ -359,70 +585,109 @@ enum // NOLINT(performance-enum-size)
TR_KEY_speed_limit_up,
TR_KEY_speed_limit_up_enabled,
TR_KEY_speed_units,
TR_KEY_start_added_torrents_kebab,
TR_KEY_start_minimized_kebab,
TR_KEY_start_date_camel,
TR_KEY_start_added_torrents,
TR_KEY_start_date,
TR_KEY_start_minimized,
TR_KEY_startDate,
TR_KEY_start_paused,
TR_KEY_status,
TR_KEY_statusbar_stats_kebab,
TR_KEY_statusbar_stats,
TR_KEY_tag,
TR_KEY_tcp_enabled_kebab,
TR_KEY_tcp_enabled,
TR_KEY_tier,
TR_KEY_time_checked,
TR_KEY_torrent_added,
TR_KEY_torrent_added_kebab,
TR_KEY_torrent_added_notification_command,
TR_KEY_torrent_added_notification_enabled_kebab,
TR_KEY_torrent_added_verify_mode_kebab,
TR_KEY_torrent_complete_notification_command,
TR_KEY_torrent_complete_notification_enabled_kebab,
TR_KEY_torrent_complete_sound_command_kebab,
TR_KEY_torrent_complete_sound_enabled_kebab,
TR_KEY_torrent_duplicate_kebab,
TR_KEY_torrent_get_kebab,
TR_KEY_torrent_set_kebab,
TR_KEY_torrent_set_location_kebab,
TR_KEY_torrent_count_camel,
TR_KEY_torrent_file_camel,
TR_KEY_torrent_added,
TR_KEY_torrent_added_notification_enabled,
TR_KEY_torrent_added_verify_mode,
TR_KEY_torrent_complete_notification_command,
TR_KEY_torrent_complete_notification_enabled,
TR_KEY_torrent_complete_sound_command,
TR_KEY_torrent_complete_sound_enabled,
TR_KEY_torrent_complete_verify_enabled,
TR_KEY_torrent_count,
TR_KEY_torrent_duplicate,
TR_KEY_torrent_file,
TR_KEY_torrent_get,
TR_KEY_torrent_set,
TR_KEY_torrent_set_location,
TR_KEY_torrentCount,
TR_KEY_torrentFile,
TR_KEY_torrent_complete_verify_enabled,
TR_KEY_torrents,
TR_KEY_totalSize,
TR_KEY_total_size_camel,
TR_KEY_total_size,
TR_KEY_trackerAdd,
TR_KEY_trackerList,
TR_KEY_trackerRemove,
TR_KEY_trackerReplace,
TR_KEY_trackerStats,
TR_KEY_tracker_add_camel,
TR_KEY_tracker_list_camel,
TR_KEY_tracker_remove_camel,
TR_KEY_tracker_replace_camel,
TR_KEY_tracker_stats_camel,
TR_KEY_tracker_add,
TR_KEY_tracker_list,
TR_KEY_tracker_remove,
TR_KEY_tracker_replace,
TR_KEY_tracker_stats,
TR_KEY_trackers,
TR_KEY_trash_can_enabled_kebab,
TR_KEY_trash_original_torrent_files_kebab,
TR_KEY_trash_can_enabled,
TR_KEY_trash_original_torrent_files,
TR_KEY_umask,
TR_KEY_units,
TR_KEY_upload_slots_per_torrent,
TR_KEY_uploadLimit,
TR_KEY_uploadLimited,
TR_KEY_uploadRatio,
TR_KEY_uploadSpeed,
TR_KEY_upload_slots_per_torrent_kebab,
TR_KEY_upload_limit_camel,
TR_KEY_upload_limited_camel,
TR_KEY_upload_ratio_camel,
TR_KEY_upload_speed_camel,
TR_KEY_upload_limit,
TR_KEY_upload_limited,
TR_KEY_upload_only,
TR_KEY_upload_ratio,
TR_KEY_upload_slots_per_torrent,
TR_KEY_upload_speed,
TR_KEY_uploaded,
TR_KEY_uploaded_bytes_kebab,
TR_KEY_uploaded_bytes_camel,
TR_KEY_uploaded_ever_camel,
TR_KEY_uploaded_bytes,
TR_KEY_uploadedBytes,
TR_KEY_uploadedEver,
TR_KEY_uploaded_ever,
TR_KEY_url_list,
TR_KEY_use_global_speed_limit_kebab,
TR_KEY_use_speed_limit_kebab,
TR_KEY_use_global_speed_limit,
TR_KEY_use_speed_limit,
TR_KEY_user_has_given_informed_consent_kebab,
TR_KEY_user_has_given_informed_consent,
TR_KEY_ut_holepunch,
TR_KEY_ut_metadata,
TR_KEY_ut_pex,
TR_KEY_utp_enabled_kebab,
TR_KEY_utp_enabled,
TR_KEY_v,
TR_KEY_version,
TR_KEY_wanted,
TR_KEY_watch_dir_kebab,
TR_KEY_watch_dir_enabled_kebab,
TR_KEY_watch_dir_force_generic_kebab,
TR_KEY_watch_dir,
TR_KEY_watch_dir_enabled,
TR_KEY_watch_dir_force_generic,
TR_KEY_webseeds,
TR_KEY_webseedsSendingToUs,
TR_KEY_webseeds_sending_to_us_camel,
TR_KEY_webseeds_sending_to_us,
TR_KEY_yourip,
TR_N_KEYS
};
@@ -447,3 +712,10 @@ enum // NOLINT(performance-enum-size)
* created.
*/
[[nodiscard]] tr_quark tr_quark_new(std::string_view str);
/**
* Get the replacement quark from old deprecated quarks.
*
* Note: Temporary shim just for the transition period to snake_case.
*/
[[nodiscard]] tr_quark tr_quark_convert(tr_quark quark);

44
libtransmission/resume.cc
View File

@@ -74,7 +74,7 @@ auto load_peers(tr_variant::Map const& map, tr_torrent* tor)
ret = tr_resume::Peers;
}
if (auto const* l = map.find_if<tr_variant::Vector>(TR_KEY_peers2_6); l != nullptr)
if (auto const* l = map.find_if<tr_variant::Vector>({ TR_KEY_peers2_6, TR_KEY_peers2_6_kebab }); l != nullptr)
{
auto const num_added = add_peers(tor, *l);
tr_logAddTraceTor(tor, fmt::format("Loaded {} IPv6 peers from resume file", num_added));
@@ -266,7 +266,7 @@ void save_idle_limits(tr_variant::Map& map, tr_torrent const* tor)
void load_single_speed_limit(tr_variant::Map const& map, tr_direction dir, tr_torrent* tor)
{
if (auto const i = map.value_if<int64_t>(TR_KEY_speed_Bps); i)
if (auto const i = map.value_if<int64_t>({ TR_KEY_speed_Bps, TR_KEY_speed_Bps_kebab }); i)
{
tor->set_speed_limit(dir, Speed{ *i, Speed::Units::Byps });
}
@@ -275,12 +275,12 @@ void load_single_speed_limit(tr_variant::Map const& map, tr_direction dir, tr_to
tor->set_speed_limit(dir, Speed{ *i2, Speed::Units::KByps });
}
if (auto const b = map.value_if<bool>(TR_KEY_use_speed_limit); b)
if (auto const b = map.value_if<bool>({ TR_KEY_use_speed_limit, TR_KEY_use_speed_limit_kebab }); b)
{
tor->use_speed_limit(dir, *b);
}
if (auto const b = map.value_if<bool>(TR_KEY_use_global_speed_limit); b)
if (auto const b = map.value_if<bool>({ TR_KEY_use_global_speed_limit, TR_KEY_use_global_speed_limit_kebab }); b)
{
tr_torrentUseSessionLimits(tor, *b);
}
@@ -290,13 +290,15 @@ auto load_speed_limits(tr_variant::Map const& map, tr_torrent* tor)
{
auto ret = tr_resume::fields_t{};
if (auto const* child = map.find_if<tr_variant::Map>(TR_KEY_speed_limit_up); child != nullptr)
if (auto const* child = map.find_if<tr_variant::Map>({ TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_kebab });
child != nullptr)
{
load_single_speed_limit(*child, TR_UP, tor);
ret = tr_resume::Speedlimit;
}
if (auto const* child = map.find_if<tr_variant::Map>(TR_KEY_speed_limit_down); child != nullptr)
if (auto const* child = map.find_if<tr_variant::Map>({ TR_KEY_speed_limit_down, TR_KEY_speed_limit_down_kebab });
child != nullptr)
{
load_single_speed_limit(*child, TR_DOWN, tor);
ret = tr_resume::Speedlimit;
@@ -307,18 +309,18 @@ auto load_speed_limits(tr_variant::Map const& map, tr_torrent* tor)
tr_resume::fields_t load_ratio_limits(tr_variant::Map const& map, tr_torrent* tor)
{
auto const* const d = map.find_if<tr_variant::Map>(TR_KEY_ratio_limit);
auto const* const d = map.find_if<tr_variant::Map>({ TR_KEY_ratio_limit, TR_KEY_ratio_limit_kebab });
if (d == nullptr)
{
return {};
}
if (auto const dratio = d->value_if<double>(TR_KEY_ratio_limit); dratio)
if (auto const dratio = d->value_if<double>({ TR_KEY_ratio_limit, TR_KEY_ratio_limit_kebab }); dratio)
{
tor->set_seed_ratio(*dratio);
}
if (auto const i = d->value_if<int64_t>(TR_KEY_ratio_mode); i)
if (auto const i = d->value_if<int64_t>({ TR_KEY_ratio_mode, TR_KEY_ratio_mode_kebab }); i)
{
tor->set_seed_ratio_mode(static_cast<tr_ratiolimit>(*i));
}
@@ -328,18 +330,18 @@ tr_resume::fields_t load_ratio_limits(tr_variant::Map const& map, tr_torrent* to
tr_resume::fields_t load_idle_limits(tr_variant::Map const& map, tr_torrent* tor)
{
auto const* const d = map.find_if<tr_variant::Map>(TR_KEY_idle_limit);
auto const* const d = map.find_if<tr_variant::Map>({ TR_KEY_idle_limit, TR_KEY_idle_limit_kebab });
if (d == nullptr)
{
return {};
}
if (auto const imin = d->value_if<int64_t>(TR_KEY_idle_limit); imin)
if (auto const imin = d->value_if<int64_t>({ TR_KEY_idle_limit, TR_KEY_idle_limit_kebab }); imin)
{
tor->set_idle_limit_minutes(*imin);
}
if (auto const i = d->value_if<int64_t>(TR_KEY_idle_mode); i)
if (auto const i = d->value_if<int64_t>({ TR_KEY_idle_mode, TR_KEY_idle_mode_kebab }); i)
{
tor->set_idle_limit_mode(static_cast<tr_idlelimit>(*i));
}
@@ -665,7 +667,8 @@ tr_resume::fields_t load_from_file(tr_torrent* tor, tr_torrent::ResumeHelper& he
if ((fields_to_load & (tr_resume::Progress | tr_resume::IncompleteDir)) != 0)
{
if (auto sv = map.value_if<std::string_view>(TR_KEY_incomplete_dir); sv && !std::empty(*sv))
if (auto sv = map.value_if<std::string_view>({ TR_KEY_incomplete_dir, TR_KEY_incomplete_dir_kebab });
sv && !std::empty(*sv))
{
helper.load_incomplete_dir(*sv);
fields_loaded |= tr_resume::IncompleteDir;
@@ -692,7 +695,7 @@ tr_resume::fields_t load_from_file(tr_torrent* tor, tr_torrent::ResumeHelper& he
if ((fields_to_load & tr_resume::MaxPeers) != 0)
{
if (auto i = map.value_if<int64_t>(TR_KEY_max_peers); i)
if (auto i = map.value_if<int64_t>({ TR_KEY_max_peers, TR_KEY_max_peers_kebab }); i)
{
tor->set_peer_limit(static_cast<uint16_t>(*i));
fields_loaded |= tr_resume::MaxPeers;
@@ -710,7 +713,7 @@ tr_resume::fields_t load_from_file(tr_torrent* tor, tr_torrent::ResumeHelper& he
if ((fields_to_load & tr_resume::AddedDate) != 0)
{
if (auto i = map.value_if<int64_t>(TR_KEY_added_date); i)
if (auto i = map.value_if<int64_t>({ TR_KEY_added_date, TR_KEY_added_date_kebab }); i)
{
helper.load_date_added(static_cast<time_t>(*i));
fields_loaded |= tr_resume::AddedDate;
@@ -719,7 +722,7 @@ tr_resume::fields_t load_from_file(tr_torrent* tor, tr_torrent::ResumeHelper& he
if ((fields_to_load & tr_resume::DoneDate) != 0)
{
if (auto i = map.value_if<int64_t>(TR_KEY_done_date); i)
if (auto i = map.value_if<int64_t>({ TR_KEY_done_date, TR_KEY_done_date_kebab }); i)
{
helper.load_date_done(static_cast<time_t>(*i));
fields_loaded |= tr_resume::DoneDate;
@@ -728,7 +731,7 @@ tr_resume::fields_t load_from_file(tr_torrent* tor, tr_torrent::ResumeHelper& he
if ((fields_to_load & tr_resume::ActivityDate) != 0)
{
if (auto i = map.value_if<int64_t>(TR_KEY_activity_date); i)
if (auto i = map.value_if<int64_t>({ TR_KEY_activity_date, TR_KEY_activity_date_kebab }); i)
{
tor->set_date_active(*i);
fields_loaded |= tr_resume::ActivityDate;
@@ -737,7 +740,7 @@ tr_resume::fields_t load_from_file(tr_torrent* tor, tr_torrent::ResumeHelper& he
if ((fields_to_load & tr_resume::TimeSeeding) != 0)
{
if (auto i = map.value_if<int64_t>(TR_KEY_seeding_time_seconds); i)
if (auto i = map.value_if<int64_t>({ TR_KEY_seeding_time_seconds, TR_KEY_seeding_time_seconds_kebab }); i)
{
helper.load_seconds_seeding_before_current_start(*i);
fields_loaded |= tr_resume::TimeSeeding;
@@ -746,7 +749,7 @@ tr_resume::fields_t load_from_file(tr_torrent* tor, tr_torrent::ResumeHelper& he
if ((fields_to_load & tr_resume::TimeDownloading) != 0)
{
if (auto i = map.value_if<int64_t>(TR_KEY_downloading_time_seconds); i)
if (auto i = map.value_if<int64_t>({ TR_KEY_downloading_time_seconds, TR_KEY_downloading_time_seconds_kebab }); i)
{
helper.load_seconds_downloading_before_current_start(*i);
fields_loaded |= tr_resume::TimeDownloading;
@@ -755,7 +758,8 @@ tr_resume::fields_t load_from_file(tr_torrent* tor, tr_torrent::ResumeHelper& he
if ((fields_to_load & tr_resume::BandwidthPriority) != 0)
{
if (auto i = map.value_if<int64_t>(TR_KEY_bandwidth_priority); i && tr_isPriority(static_cast<tr_priority_t>(*i)))
if (auto i = map.value_if<int64_t>({ TR_KEY_bandwidth_priority, TR_KEY_bandwidth_priority_kebab });
i && tr_isPriority(static_cast<tr_priority_t>(*i)))
{
tr_torrentSetPriority(tor, static_cast<tr_priority_t>(*i));
fields_loaded |= tr_resume::BandwidthPriority;

9
libtransmission/rpc-server.cc
View File

@@ -52,7 +52,7 @@
struct evbuffer;
/* session-id is used to make cross-site request forgery attacks difficult.
/* session_id is used to make cross-site request forgery attacks difficult.
* Don't disable this feature unless you really know what you're doing!
* https://en.wikipedia.org/wiki/Cross-site_request_forgery
* https://shiflett.org/articles/cross-site-request-forgeries
@@ -599,7 +599,7 @@ void handle_request(struct evhttp_request* req, void* arg)
"<li>Enable password authentication, then any hostname is allowed.</li>"
"<li>Add the hostname you want to use to the whitelist in settings.</li>"
"</ul></p>"
"<p>If you're editing settings.json, see the 'rpc-host-whitelist' and 'rpc-host-whitelist-enabled' entries.</p>"
"<p>If you're editing settings.json, see the 'rpc_host_whitelist' and 'rpc_host_whitelist_enabled' entries.</p>"
"<p>This requirement has been added to help prevent "
"<a href=\"https://en.wikipedia.org/wiki/DNS_rebinding\">DNS Rebinding</a> "
"attacks.</p>";
@@ -612,9 +612,10 @@ void handle_request(struct evhttp_request* req, void* arg)
{
auto const session_id = std::string{ server->session->sessionId() };
auto const body = fmt::format(
"<p>Your request had an invalid session-id header.</p>"
"<p>Your request had an invalid session_id header.</p>"
"<p>To fix this, follow these steps:"
"<ol><li> When reading a response, get its X-Transmission-Session-Id header and remember it"
"<ol><li> When reading a response, get its " TR_RPC_SESSION_ID_HEADER
" header and remember it"
"<li> Add the updated header to your outgoing requests"
"<li> When you get this 409 error message, resend your request with the updated header"
"</ol></p>"

1085
libtransmission/rpcimpl.cc
View File

File diff suppressed because it is too large Load Diff

21
libtransmission/session.cc
View File

@@ -101,29 +101,30 @@ void bandwidthGroupRead(tr_session* session, std::string_view config_dir)
auto& group = session->getBandwidthGroup(tr_interned_string{ key });
auto limits = tr_bandwidth_limits{};
if (auto const val = group_map->value_if<bool>(TR_KEY_uploadLimited))
if (auto const val = group_map->value_if<bool>({ TR_KEY_upload_limited, TR_KEY_upload_limited_camel }); val)
{
limits.up_limited = *val;
}
if (auto const val = group_map->value_if<bool>(TR_KEY_downloadLimited))
if (auto const val = group_map->value_if<bool>({ TR_KEY_download_limited, TR_KEY_download_limited_camel }); val)
{
limits.down_limited = *val;
}
if (auto const val = group_map->value_if<int64_t>(TR_KEY_uploadLimit))
if (auto const val = group_map->value_if<int64_t>({ TR_KEY_upload_limit, TR_KEY_upload_limit_camel }); val)
{
limits.up_limit = Speed{ *val, Speed::Units::KByps };
}
if (auto const val = group_map->value_if<int64_t>(TR_KEY_downloadLimit))
if (auto const val = group_map->value_if<int64_t>({ TR_KEY_download_limit, TR_KEY_download_limit_camel }); val)
{
limits.down_limit = Speed{ *val, Speed::Units::KByps };
}
group.set_limits(limits);
if (auto const val = group_map->value_if<bool>(TR_KEY_honorsSessionLimits))
if (auto const val = group_map->value_if<bool>({ TR_KEY_honors_session_limits, TR_KEY_honors_session_limits_camel });
val)
{
group.honor_parent_limits(TR_UP, *val);
group.honor_parent_limits(TR_DOWN, *val);
@@ -139,12 +140,12 @@ void bandwidthGroupWrite(tr_session const* session, std::string_view config_dir)
{
auto const limits = group->get_limits();
auto group_map = tr_variant::Map{ 6U };
group_map.try_emplace(TR_KEY_downloadLimit, limits.down_limit.count(Speed::Units::KByps));
group_map.try_emplace(TR_KEY_downloadLimited, limits.down_limited);
group_map.try_emplace(TR_KEY_honorsSessionLimits, group->are_parent_limits_honored(TR_UP));
group_map.try_emplace(TR_KEY_download_limit, limits.down_limit.count(Speed::Units::KByps));
group_map.try_emplace(TR_KEY_download_limited, limits.down_limited);
group_map.try_emplace(TR_KEY_honors_session_limits, group->are_parent_limits_honored(TR_UP));
group_map.try_emplace(TR_KEY_name, name.sv());
group_map.try_emplace(TR_KEY_uploadLimit, limits.up_limit.count(Speed::Units::KByps));
group_map.try_emplace(TR_KEY_uploadLimited, limits.up_limited);
group_map.try_emplace(TR_KEY_upload_limit, limits.up_limit.count(Speed::Units::KByps));
group_map.try_emplace(TR_KEY_upload_limited, limits.up_limited);
groups_map.try_emplace(name.quark(), std::move(group_map));
}

8
libtransmission/session.h
View File

@@ -1266,10 +1266,10 @@ public:
/// constexpr fields
static constexpr std::array<std::tuple<tr_quark, tr_quark, TrScript>, 3> Scripts{
{ { TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_filename, TR_SCRIPT_ON_TORRENT_ADDED },
{ TR_KEY_script_torrent_done_enabled, TR_KEY_script_torrent_done_filename, TR_SCRIPT_ON_TORRENT_DONE },
{ TR_KEY_script_torrent_done_seeding_enabled,
TR_KEY_script_torrent_done_seeding_filename,
{ { TR_KEY_script_torrent_added_enabled_kebab, TR_KEY_script_torrent_added_filename_kebab, TR_SCRIPT_ON_TORRENT_ADDED },
{ TR_KEY_script_torrent_done_enabled_kebab, TR_KEY_script_torrent_done_filename_kebab, TR_SCRIPT_ON_TORRENT_DONE },
{ TR_KEY_script_torrent_done_seeding_enabled_kebab,
TR_KEY_script_torrent_done_seeding_filename_kebab,
TR_SCRIPT_ON_TORRENT_DONE_SEEDING } }
};

15
libtransmission/stats.cc
View File

@@ -3,6 +3,7 @@
// or any future license endorsed by Mnemosyne LLC.
// License text can be found in the licenses/ folder.
#include <initializer_list>
#include <optional>
#include <utility>
@@ -51,9 +52,9 @@ tr_session_stats tr_stats::load_old_stats(std::string_view config_dir)
return {};
}
auto const load = [map](tr_quark const quark, uint64_t& dst)
auto const load = [map](std::initializer_list<tr_quark> keys, uint64_t& dst)
{
if (auto const val = map->value_if<int64_t>(quark); val)
if (auto const val = map->value_if<int64_t>(keys); val)
{
dst = *val;
}
@@ -61,11 +62,11 @@ tr_session_stats tr_stats::load_old_stats(std::string_view config_dir)
auto ret = tr_session_stats{};
load(TR_KEY_downloaded_bytes, ret.downloadedBytes);
load(TR_KEY_files_added, ret.filesAdded);
load(TR_KEY_seconds_active, ret.secondsActive);
load(TR_KEY_session_count, ret.sessionCount);
load(TR_KEY_uploaded_bytes, ret.uploadedBytes);
load({ TR_KEY_downloaded_bytes, TR_KEY_downloaded_bytes_kebab }, ret.downloadedBytes);
load({ TR_KEY_files_added, TR_KEY_files_added_kebab }, ret.filesAdded);
load({ TR_KEY_seconds_active, TR_KEY_seconds_active_kebab }, ret.secondsActive);
load({ TR_KEY_session_count, TR_KEY_session_count_kebab }, ret.sessionCount);
load({ TR_KEY_uploaded_bytes, TR_KEY_uploaded_bytes_kebab }, ret.uploadedBytes);
return ret;
}

6
libtransmission/transmission.h
View File

@@ -376,7 +376,7 @@ enum tr_rpc_callback_type : uint8_t
TR_RPC_TORRENT_STOPPED,
TR_RPC_TORRENT_REMOVING,
TR_RPC_TORRENT_TRASHING, /* _REMOVING + delete local data */
TR_RPC_TORRENT_CHANGED, /* catch-all for the "torrent-set" rpc method */
TR_RPC_TORRENT_CHANGED, /* catch-all for the "torrent_set" rpc method */
TR_RPC_TORRENT_MOVED,
TR_RPC_SESSION_CHANGED,
TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED, /* catch potentially multiple torrents being moved in the queue */
@@ -725,11 +725,11 @@ void tr_blocklistSetEnabled(tr_session* session, bool is_enabled);
char const* tr_blocklistGetURL(tr_session const* session);
/** @brief The blocklist that gets updated when an RPC client
invokes the "blocklist-update" method */
invokes the "blocklist_update" method */
void tr_blocklistSetURL(tr_session* session, char const* url);
/** @brief the file in the $config/blocklists/ directory that's
used by `tr_blocklistSetContent()` and "blocklist-update" */
used by `tr_blocklistSetContent()` and "blocklist_update" */
#define DEFAULT_BLOCKLIST_FILENAME "blocklist.bin"
/** @} */

2
libtransmission/variant.cc
View File

@@ -253,7 +253,7 @@ void tr_variant::Merge::operator()(tr_variant::Map const& src)
tgt->reserve(std::size(*tgt) + std::size(src));
for (auto const& [key, val] : src)
{
std::visit(Merge{ (*tgt)[key] }, val.val_);
std::visit(Merge{ (*tgt)[tr_quark_convert(key)] }, val.val_);
}
}
}

44
libtransmission/variant.h
View File

@@ -8,6 +8,7 @@
#include <algorithm> // std::move()
#include <cstddef> // size_t
#include <cstdint> // int64_t
#include <initializer_list>
#include <optional>
#include <string>
#include <string_view>
@@ -95,11 +96,21 @@ public:
[[nodiscard]] TR_CONSTEXPR20 auto find(tr_quark const key) const noexcept
{
auto const predicate = [key](auto const& item)
return Vector::const_iterator{ const_cast<Map*>(this)->find(key) };
}
[[nodiscard]] TR_CONSTEXPR20 auto find(std::initializer_list<tr_quark> keys) noexcept
{
static auto constexpr Predicate = [](auto const& item, tr_quark key)
{
return item.first == key;
};
return std::find_if(std::cbegin(vec_), std::cend(vec_), predicate);
return std::find_first_of(std::begin(vec_), std::end(vec_), std::begin(keys), std::end(keys), Predicate);
}
[[nodiscard]] TR_CONSTEXPR20 auto find(std::initializer_list<tr_quark> keys) const noexcept
{
return Vector::const_iterator{ const_cast<Map*>(this)->find(keys) };
}
[[nodiscard]] TR_CONSTEXPR20 auto size() const noexcept
@@ -163,19 +174,31 @@ public:
// --- custom functions
template<typename Type>
[[nodiscard]] TR_CONSTEXPR20 auto find_if(tr_quark const key) noexcept
[[nodiscard]] TR_CONSTEXPR20 auto* find_if(tr_quark const key) noexcept
{
auto const iter = find(key);
return iter != end() ? iter->second.get_if<Type>() : nullptr;
}
template<typename Type>
[[nodiscard]] TR_CONSTEXPR20 auto find_if(tr_quark const key) const noexcept
[[nodiscard]] TR_CONSTEXPR20 auto const* find_if(tr_quark const key) const noexcept
{
auto const iter = find(key);
return const_cast<Map*>(this)->find_if<Type>(key);
}
template<typename Type>
[[nodiscard]] TR_CONSTEXPR20 auto* find_if(std::initializer_list<tr_quark> keys) noexcept
{
auto const iter = find(keys);
return iter != end() ? iter->second.get_if<Type>() : nullptr;
}
template<typename Type>
[[nodiscard]] TR_CONSTEXPR20 auto* find_if(std::initializer_list<tr_quark> keys) const noexcept
{
return const_cast<Map*>(this)->find_if<Type>(keys);
}
template<typename Type>
[[nodiscard]] std::optional<Type> value_if(tr_quark const key) const noexcept
{
@@ -187,6 +210,17 @@ public:
return {};
}
template<typename Type>
[[nodiscard]] std::optional<Type> value_if(std::initializer_list<tr_quark> keys) const noexcept
{
if (auto it = find(keys); it != end())
{
return it->second.value_if<Type>();
}
return {};
}
private:
using Vector = std::vector<std::pair<tr_quark, tr_variant>>;
Vector vec_;