59 Commits
Author SHA1 Message Date
vcoppe da8a9e3d84 handle self closing elements 2026-10-04 22:01:23 +02:00
vcoppe c6bd5b06e8 clean tool 2026-10-04 20:38:46 +02:00
vcoppe c04367dd86 progress 2026-10-04 19:19:53 +02:00
vcoppe 5e2f506120 progress 2026-10-04 19:14:41 +02:00
vcoppe c536e6247b progress 2026-10-04 17:29:57 +02:00
vcoppe 594d714b7f small fix 2026-10-04 17:19:35 +02:00
vcoppe 543fecadb8 fix popups 2026-10-04 17:09:41 +02:00
vcoppe 017d8521d6 use engine info 2026-10-04 16:27:03 +02:00
vcoppe 78e9d45072 small fix 2026-10-04 16:21:48 +02:00
vcoppe 7651d859c4 progress 2026-10-04 16:11:44 +02:00
vcoppe ec448b72e2 progress 2026-10-04 15:47:09 +02:00
vcoppe bf946f179a progress 2026-10-04 15:26:58 +02:00
vcoppe 9ff9b5475a progress 2026-10-04 15:03:37 +02:00
vcoppe 55f1d275b7 progress 2026-10-04 14:49:53 +02:00
vcoppe 1d534881f8 progress 2026-10-04 13:18:18 +02:00
vcoppe 03cbacfbb4 fix 2026-10-04 12:33:15 +02:00
vcoppe 9d0905959b fix markers 2026-10-04 12:23:42 +02:00
vcoppe b7ca462f58 progress 2026-10-04 11:52:46 +02:00
vcoppe 9015da4876 fixes 2026-10-04 11:07:12 +02:00
vcoppe f458a1104f progress 2026-10-04 11:00:46 +02:00
vcoppe caba9388af progress 2026-10-04 10:29:39 +02:00
vcoppe 763a7406ce progress 2026-10-04 10:15:51 +02:00
vcoppe 68c8933c35 progress 2026-10-04 09:55:08 +02:00
vcoppe 84b1558b2e progress 2026-10-04 09:50:34 +02:00
vcoppe cd870f0186 visibility 2026-10-04 09:40:17 +02:00
vcoppe 9ac2a2b69c progress 2026-10-04 08:53:00 +02:00
vcoppe 86aba8f4b1 progress 2026-10-04 08:26:15 +02:00
vcoppe 74b674e8e8 progress 2026-10-04 08:21:39 +02:00
vcoppe f1904bc12f cleaning 2026-10-03 20:54:05 +02:00
vcoppe 9afba53e5d progress 2026-10-03 19:50:38 +02:00
vcoppe fd76e0fa46 progress 2026-10-03 19:17:58 +02:00
vcoppe 438a87f06f progress 2026-10-03 19:08:56 +02:00
vcoppe a994e16f51 splice 2026-10-03 18:03:13 +02:00
vcoppe 639e7491eb merge methods into 1 2026-10-03 17:47:04 +02:00
vcoppe 891a08a3cc progress 2026-10-03 17:42:26 +02:00
vcoppe 0c07164dec remove (copy) in name 2026-10-03 17:26:53 +02:00
vcoppe f133d55889 progress 2026-10-03 17:21:16 +02:00
vcoppe fbb636cb06 progress 2026-10-03 16:52:21 +02:00
vcoppe bddceb28aa keep style info 2026-10-03 16:43:53 +02:00
vcoppe bff84fa24c progress 2026-10-03 16:40:17 +02:00
vcoppe 64914f9aa0 progress 2026-10-03 16:16:47 +02:00
vcoppe 2abf46c747 progress 2026-10-03 15:33:44 +02:00
vcoppe 888f41e979 refactoring 2026-10-03 13:56:16 +02:00
vcoppe 17533586ef progress 2026-10-03 13:41:58 +02:00
vcoppe c6ad088947 fix 2026-10-03 13:40:49 +02:00
vcoppe 87d6d5f30e change type 2026-10-03 11:49:10 +02:00
vcoppe dbe894b3a3 reorganize 2026-10-03 10:03:22 +02:00
vcoppe a921d4b9cd fixes 2026-10-02 18:50:10 +02:00
vcoppe b7db73cf77 progress 2026-10-02 18:06:45 +02:00
vcoppe 5868595a6c progress 2026-10-01 18:42:31 +02:00
vcoppe eb8e09b835 progress 2026-09-30 19:19:23 +02:00
vcoppe 41dc853f65 progress 2026-09-25 12:09:58 +02:00
vcoppe 27c0a57cc1 progress 2026-09-24 20:55:30 +02:00
vcoppe 497ac120ec progress 2026-09-23 19:53:39 +02:00
vcoppe a486016d96 progress 2026-09-21 23:49:57 +02:00
vcoppe cc5f5653ef progress 2026-09-20 13:58:27 +02:00
vcoppe 20222c450d parsing continued 2026-09-18 09:50:04 +02:00
vcoppe 69049e1345 parsing start 2026-09-18 09:03:51 +02:00
vcoppe ed6264444f wasm first steps 2026-07-14 18:36:30 +02:00
809 changed files with 54614 additions and 48802 deletions

No files matched your search

-67
View File
@@ -1,67 +0,0 @@
name: Deploy to Cloudflare Pages
on:
push:
branches: 'dev'
workflow_dispatch:
concurrency:
group: cloudflare-${{ github.ref }}
cancel-in-progress: true
jobs:
deploy:
runs-on: ubuntu-latest
permissions:
contents: read
deployments: write
steps:
- name: Checkout
uses: actions/checkout@v5
- name: Install Node.js
uses: actions/setup-node@v6
with:
node-version: 24
cache: npm
cache-dependency-path: website/package-lock.json
- name: Install Rust
uses: dtolnay/rust-toolchain@stable
with:
targets: wasm32-unknown-unknown
- name: Install wasm-pack
uses: taiki-e/install-action@v2
with:
tool: wasm-pack
- name: Test gpx-rs
run: cargo test
- name: Build wasm
run: wasm-pack build --target bundler
working-directory: wasm
- name: Install dependencies for website
run: npm install --prefix website
- name: Test website
run: npm test --prefix website
- name: Create env file
run: echo PUBLIC_MAPTILER_KEY=${{ secrets.PUBLIC_MAPTILER_KEY }} >> website/.env
- name: Build website
env:
BASE_PATH: ''
run: npm run build --prefix website
- name: Deploy to Cloudflare Pages
uses: cloudflare/wrangler-action@v3
with:
apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
command: pages deploy website/build --project-name=${{ vars.CLOUDFLARE_PROJECT_NAME || 'gpxstudio' }} --branch=${{ github.ref_name }} --commit-dirty=true
gitHubToken: ${{ secrets.GITHUB_TOKEN }}
+7 -19
View File
@@ -15,31 +15,19 @@ jobs:
with: with:
node-version: 24 node-version: 24
cache: npm cache: npm
cache-dependency-path: website/package-lock.json cache-dependency-path: |
gpx/package-lock.json
website/package-lock.json
- name: Install Rust - name: Install dependencies for gpx
uses: dtolnay/rust-toolchain@stable run: npm install --prefix gpx
with:
targets: wasm32-unknown-unknown
- name: Install wasm-pack - name: Build gpx
uses: taiki-e/install-action@v2 run: npm run build --prefix gpx
with:
tool: wasm-pack
- name: Test gpx-rs
run: cargo test
- name: Build wasm
run: wasm-pack build --target bundler
working-directory: wasm
- name: Install dependencies for website - name: Install dependencies for website
run: npm install --prefix website run: npm install --prefix website
- name: Test website
run: npm test --prefix website
- name: Create env file - name: Create env file
run: | run: |
touch website/.env touch website/.env
-124
View File
@@ -1,124 +0,0 @@
name: Desktop beta
on:
push:
branches: 'dev'
workflow_dispatch:
concurrency:
group: desktop-beta-${{ github.ref }}
cancel-in-progress: true
jobs:
build:
strategy:
fail-fast: false
matrix:
include:
- platform: macos-latest
rust_targets: aarch64-apple-darwin,x86_64-apple-darwin,wasm32-unknown-unknown
args: --target universal-apple-darwin
bundles: target/universal-apple-darwin/release/bundle/dmg/*.dmg
# the oldest supported Ubuntu, so that the AppImage runs on older systems too
- platform: ubuntu-22.04
rust_targets: wasm32-unknown-unknown
args: ''
bundles: |
target/release/bundle/deb/*.deb
target/release/bundle/rpm/*.rpm
target/release/bundle/appimage/*.AppImage
- platform: windows-latest
rust_targets: wasm32-unknown-unknown
args: ''
bundles: |
target/release/bundle/msi/*.msi
target/release/bundle/nsis/*.exe
runs-on: ${{ matrix.platform }}
steps:
- name: Checkout
uses: actions/checkout@v5
- name: Install Linux dependencies
if: runner.os == 'Linux'
run: |
sudo apt-get update
sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
- name: Install Node.js
uses: actions/setup-node@v6
with:
node-version: 24
cache: npm
cache-dependency-path: website/package-lock.json
- name: Install Rust
uses: dtolnay/rust-toolchain@stable
with:
targets: ${{ matrix.rust_targets }}
- name: Cache Rust build
uses: Swatinem/rust-cache@v2
- name: Install wasm-pack
uses: taiki-e/install-action@v2
with:
tool: wasm-pack
# the desktop app does not use it, but the website depends on its package
- name: Build wasm
run: wasm-pack build --target bundler
working-directory: wasm
- name: Install dependencies for website
run: npm install --prefix website
# the key would be readable in the app: it is left empty, so only the MapTiler layer fails
- name: Create env file
run: echo "PUBLIC_MAPTILER_KEY=" >> website/.env
- name: Build app
run: npx --yes @tauri-apps/cli@2 build ${{ matrix.args }}
working-directory: tauri
# after the build, which gives the app the website it embeds
- name: Test engine and app
run: cargo test -p gpx-engine -p gpx-studio-desktop
- name: Upload bundles
uses: actions/upload-artifact@v4
with:
name: bundles-${{ matrix.platform }}
path: ${{ matrix.bundles }}
if-no-files-found: error
# replaces the beta release only once every platform is built
release:
needs: build
runs-on: ubuntu-latest
permissions:
contents: write
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
GH_REPO: ${{ github.repository }}
steps:
- name: Download bundles
uses: actions/download-artifact@v5
with:
pattern: bundles-*
path: bundles
merge-multiple: true
- name: Publish beta release
# the bundles of a platform are in a folder per format (deb, msi…)
run: |
mapfile -t files < <(find bundles -type f)
gh release delete desktop-beta --cleanup-tag --yes || true
gh release create desktop-beta "${files[@]}" \
--prerelease \
--target ${{ github.sha }} \
--title "Desktop beta" \
--notes "Beta of the desktop app, built from ${{ github.sha }} on the dev branch. The builds are not signed yet: macOS and Windows will warn before opening them."
+1 -2
View File
@@ -1,2 +1 @@
.DS_Store .DS_Store
target/
Generated
-5330
View File
File diff suppressed because it is too large. Load diff
-5
View File
@@ -1,5 +0,0 @@
[workspace]
members = ["gpx-rs", "wasm", "tauri"]
# `cargo test` at the root only tests the engine: the others need their own tooling
default-members = ["gpx-rs"]
resolver = "3"
+11 -9
View File
@@ -25,20 +25,19 @@ Any help is greatly appreciated!
## Development ## Development
The code is split into four parts: The code is split into two parts:
- `gpx-rs`: a Rust library for parsing and manipulating GPX files (the engine), and the interface to it that the next two share (`gpx_engine::api`), - `gpx`: a Typescript library for parsing and manipulating GPX files,
- `wasm`: the engine for the browser, compiled to WebAssembly, - `website`: the website itself, which is a [SvelteKit](https://kit.svelte.dev/) application.
- `tauri`: the desktop app, which runs the engine natively,
- `website`: the website itself, which is a [SvelteKit](https://kit.svelte.dev/) application. It also is the UI of the desktop app.
You will need [Node.js](https://nodejs.org/), [Rust](https://rustup.rs/) and [wasm-pack](https://rustwasm.github.io/wasm-pack/) to build and run the website. See [`tauri`](tauri/README.md) for the desktop app. You will need [Node.js](https://nodejs.org/) to build and run these two parts.
### Building the WebAssembly engine ### Building the `gpx` library
```bash ```bash
cd wasm cd gpx
wasm-pack build --target bundler npm install
npm run build
``` ```
### Running the website ### Running the website
@@ -65,6 +64,9 @@ This project has been made possible thanks to the following open source projects
- [tailwindcss](https://github.com/tailwindlabs/tailwindcss) — easy styling - [tailwindcss](https://github.com/tailwindlabs/tailwindcss) — easy styling
- [Chart.js](https://github.com/chartjs/Chart.js) — beautiful and fast charts - [Chart.js](https://github.com/chartjs/Chart.js) — beautiful and fast charts
- Logic: - Logic:
- [immer](https://github.com/immerjs/immer) — complex state management
- [Dexie.js](https://github.com/dexie/Dexie.js) — IndexedDB wrapper
- [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser) — fast GPX file parsing
- [SortableJS](https://github.com/SortableJS/Sortable) — creating a sortable file tree - [SortableJS](https://github.com/SortableJS/Sortable) — creating a sortable file tree
- Mapping: - Mapping:
- [MapLibre GL JS](https://github.com/maplibre/maplibre-gl-js) — beautiful and fast interactive map rendering - [MapLibre GL JS](https://github.com/maplibre/maplibre-gl-js) — beautiful and fast interactive map rendering
+2
View File
@@ -0,0 +1,2 @@
target/
pkg/
+398
View File
@@ -0,0 +1,398 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "android_system_properties"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc"
dependencies = [
"libc",
]
[[package]]
name = "autocfg"
version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
[[package]]
name = "bumpalo"
version = "3.20.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
[[package]]
name = "cc"
version = "1.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a3eb0f42d6c360dc3f8a821f6bf2fdea7f72bfd36b3076eb0e6d1e9e0752fff4"
dependencies = [
"find-msvc-tools",
"shlex",
]
[[package]]
name = "cfg-if"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
[[package]]
name = "chrono"
version = "0.4.45"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
dependencies = [
"iana-time-zone",
"js-sys",
"num-traits",
"wasm-bindgen",
"windows-link",
]
[[package]]
name = "console_error_panic_hook"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
dependencies = [
"cfg-if",
"wasm-bindgen",
]
[[package]]
name = "core-foundation-sys"
version = "0.8.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
[[package]]
name = "find-msvc-tools"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3e0f1c7c3a72c66fd80abe965175f7523475c0489a87d3ff9d6e8c87d87a9d2d"
[[package]]
name = "futures-core"
version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
[[package]]
name = "futures-task"
version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
[[package]]
name = "futures-util"
version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
dependencies = [
"futures-core",
"futures-task",
"pin-project-lite",
"slab",
]
[[package]]
name = "getrandom"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
dependencies = [
"cfg-if",
"libc",
"r-efi",
]
[[package]]
name = "gpx-engine"
version = "0.1.0"
dependencies = [
"chrono",
"quick-xml",
"uuid",
]
[[package]]
name = "gpx-rs"
version = "0.1.0"
dependencies = [
"console_error_panic_hook",
"gpx-engine",
"js-sys",
"uuid",
"wasm-bindgen",
]
[[package]]
name = "iana-time-zone"
version = "0.1.65"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
dependencies = [
"android_system_properties",
"core-foundation-sys",
"iana-time-zone-haiku",
"js-sys",
"log",
"wasm-bindgen",
"windows-core",
]
[[package]]
name = "iana-time-zone-haiku"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
dependencies = [
"cc",
]
[[package]]
name = "js-sys"
version = "0.3.106"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
dependencies = [
"cfg-if",
"futures-util",
"wasm-bindgen",
]
[[package]]
name = "libc"
version = "0.2.189"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
[[package]]
name = "log"
version = "0.4.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
[[package]]
name = "memchr"
version = "2.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
[[package]]
name = "num-traits"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
dependencies = [
"autocfg",
]
[[package]]
name = "once_cell"
version = "1.21.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
[[package]]
name = "pin-project-lite"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
[[package]]
name = "proc-macro2"
version = "1.0.106"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quick-xml"
version = "0.42.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
dependencies = [
"memchr",
]
[[package]]
name = "quote"
version = "1.0.46"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
dependencies = [
"proc-macro2",
]
[[package]]
name = "r-efi"
version = "6.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
[[package]]
name = "rustversion"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
[[package]]
name = "shlex"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
[[package]]
name = "slab"
version = "0.4.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
[[package]]
name = "syn"
version = "2.0.118"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "syn"
version = "3.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "unicode-ident"
version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
[[package]]
name = "uuid"
version = "1.26.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2ef6dac1e96601b4fb3acccccff2139741fcb757cb9a36089bf5be91cfb285ce"
dependencies = [
"getrandom",
"js-sys",
"wasm-bindgen",
]
[[package]]
name = "wasm-bindgen"
version = "0.2.129"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
dependencies = [
"cfg-if",
"once_cell",
"rustversion",
"wasm-bindgen-macro",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-macro"
version = "0.2.129"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
]
[[package]]
name = "wasm-bindgen-macro-support"
version = "0.2.129"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
dependencies = [
"bumpalo",
"proc-macro2",
"quote",
"syn 3.0.6",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
version = "0.2.129"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
dependencies = [
"unicode-ident",
]
[[package]]
name = "windows-core"
version = "0.62.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
dependencies = [
"windows-implement",
"windows-interface",
"windows-link",
"windows-result",
"windows-strings",
]
[[package]]
name = "windows-implement"
version = "0.60.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.118",
]
[[package]]
name = "windows-interface"
version = "0.59.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.118",
]
[[package]]
name = "windows-link"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
[[package]]
name = "windows-result"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
dependencies = [
"windows-link",
]
[[package]]
name = "windows-strings"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
dependencies = [
"windows-link",
]
+5 -10
View File
@@ -1,11 +1,6 @@
[package] [workspace]
name = "gpx-engine" members = ["engine", "wasm"]
version = "0.1.0" resolver = "3"
edition = "2024"
[dependencies] [profile.release]
chrono = "0.4.45" debug = true
postcard = { version = "1.1.3", features = ["use-std"] }
quick-xml = "0.42.0"
serde = { version = "1.0.229", features = ["derive"] }
uuid = { version = "1.26.1", features = ["serde", "v4"] }
+3 -10
View File
@@ -1,10 +1,3 @@
# gpx-rs ```
wasm-pack build wasm --target bundler --out-dir ../pkg
The GPX engine: plain Rust, no knowledge of who uses it. Tested natively with `cargo test` (from ```
here or from the root).
- `src/core`, `src/engine`, `src/storage`: the engine itself.
- `src/api`: the interface to the engine that the frontends (`../wasm`, `../tauri`) share. Each
function takes the engine and typed arguments, and gives plain data (`api::dto`, serde types, or
slices for the numeric buffers). A frontend only converts what crosses: ids from strings or
bytes, results to JS objects or JSON, slices to typed arrays or raw bytes.
-38
View File
@@ -1,38 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<gpx xmlns="http://www.topografix.com/GPX/1/1" version="1.1" creator="test">
<metadata>
<name>with links</name>
<author>
<name>someone</name>
<email id="someone" domain="example.com"/>
<link href="https://example.com/author"><text>author</text></link>
</author>
<link href="https://example.com/file-1"><text>first</text></link>
<link href="https://example.com/file-2"/>
</metadata>
<wpt lat="50" lon="4">
<name>summit</name>
<link href="https://example.com/wpt-1"><text>one</text></link>
<link href="https://example.com/wpt-2"/>
<link href="https://example.com/wpt-3"><text>three</text></link>
</wpt>
<trk>
<name>track</name>
<link href="https://example.com/trk-1"/>
<link href="https://example.com/trk-2"><text>two</text></link>
<trkseg>
<trkpt lat="50" lon="4"/>
<trkpt lat="50.1" lon="4.1"/>
</trkseg>
</trk>
<rte>
<name>route</name>
<link href="https://example.com/rte-1"/>
<link href="https://example.com/rte-2"/>
<rtept lat="51" lon="5"/>
<rtept lat="51.1" lon="5.1"/>
</rte>
<wpt lat="51" lon="5">
<name>email variants</name>
</wpt>
</gpx>
-23
View File
@@ -1,23 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<gpx xmlns="http://www.topografix.com/GPX/1/1" xmlns:gpxx="http://www.garmin.com/xmlschemas/GpxExtensions/v3" version="1.1" creator="test">
<rte>
<name>with extensions</name>
<rtept lat="1" lon="1">
<ele>10</ele>
<extensions>
<gpxx:RoutePointExtension>
<gpxx:rpt lat="1.1" lon="1.1"/>
<gpxx:rpt lat="1.2" lon="1.2"></gpxx:rpt>
</gpxx:RoutePointExtension>
</extensions>
</rtept>
<rtept lat="2" lon="2">
<ele>20</ele>
<time>2024-01-01T00:00:00Z</time>
</rtept>
<rtept lat="3" lon="3"/>
</rte>
<rte>
<name>empty</name>
</rte>
</gpx>
-30
View File
@@ -1,30 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<gpx xmlns="http://www.topografix.com/GPX/1/1" xmlns:gpxx="http://www.garmin.com/xmlschemas/GpxExtensions/v3" version="1.1" creator="test">
<rte>
<name>Lausanne</name>
<cmt>comment</cmt>
<desc>description</desc>
<type>Cycling</type>
<rtept lat="46.544628096744418" lon="6.658079791814089">
<ele>500</ele>
<extensions>
<gpxx:RoutePointExtension>
<gpxx:rpt lat="46.544483928009868" lon="6.658018603920937"/>
<gpxx:rpt lat="46.544415950775146" lon="6.658358573913574"/>
<gpxx:rpt lat="46.544415950775146" lon="6.658358573913574"/>
</gpxx:RoutePointExtension>
</extensions>
</rtept>
<rtept lat="46.544100000000000" lon="6.659000000000000">
<ele>510</ele>
<extensions>
<gpxx:RoutePointExtension>
<gpxx:rpt lat="46.543900000000000" lon="6.659500000000000"/>
</gpxx:RoutePointExtension>
</extensions>
</rtept>
<rtept lat="46.543000000000000" lon="6.660000000000000">
<ele>505</ele>
</rtept>
</rte>
</gpx>
+9
View File
@@ -0,0 +1,9 @@
[package]
name = "gpx-engine"
version = "0.1.0"
edition = "2024"
[dependencies]
chrono = "0.4.45"
quick-xml = "0.42.0"
uuid = { version = "1.26.1", features = ["v4"] }
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
+4
View File
@@ -0,0 +1,4 @@
mod simplify;
mod smooth;
pub use simplify::*;
@@ -0,0 +1,133 @@
use crate::{
core::gpx::{TrackSegment, TrackSegmentIndex},
core::utils::crossarc,
};
pub fn ramer_douglas_peucker<F>(
trkseg: &TrackSegment,
mapping: &F,
epsilon: f64,
) -> Vec<TrackSegmentIndex>
where
F: Fn(TrackSegmentIndex) -> (f64, f64),
{
match trkseg.len() {
0 => vec![],
1 => vec![trkseg.first_index().unwrap()],
2 => vec![trkseg.first_index().unwrap(), trkseg.last_index().unwrap()],
_ => {
let first = trkseg.first_index().unwrap();
let last = trkseg.last_index().unwrap();
let mut indices = vec![first];
ramer_douglas_peucker_helper(trkseg, first, last, mapping, epsilon, &mut indices);
indices.push(last);
indices
}
}
}
fn ramer_douglas_peucker_helper<F>(
trkseg: &TrackSegment,
start: TrackSegmentIndex,
end: TrackSegmentIndex,
mapping: &F,
epsilon: f64,
indices: &mut Vec<TrackSegmentIndex>,
) where
F: Fn(TrackSegmentIndex) -> (f64, f64),
{
let mut max_idx = None;
let mut max_dist = 0.0;
let start_pt = mapping(start);
let end_pt = mapping(end);
let mut cur = trkseg.next_index(Some(start));
while let Some(idx) = cur {
if idx == end {
break;
}
let pt = mapping(idx);
let dist = crossarc(start_pt.0, start_pt.1, end_pt.0, end_pt.1, pt.0, pt.1);
if dist > max_dist {
max_idx = Some(idx);
max_dist = dist;
}
cur = trkseg.next_index(cur);
}
if let Some(idx) = max_idx.filter(|_| max_dist > epsilon) {
ramer_douglas_peucker_helper(trkseg, start, idx, mapping, epsilon, indices);
indices.push(idx);
ramer_douglas_peucker_helper(trkseg, idx, end, mapping, epsilon, indices);
}
}
#[cfg(test)]
mod tests {
use crate::{Trackpoint, TrackpointChunk};
use super::*;
fn segment(eles: &[f64]) -> TrackSegment {
let mut trkseg = TrackSegment::default();
// several small chunks, to also exercise the chunk boundaries
for part in eles.chunks(3) {
let mut chunk = TrackpointChunk::default();
for ele in part {
chunk.trkpt.push(Trackpoint {
ele: *ele,
..Default::default()
});
}
trkseg.push(chunk);
}
trkseg
}
fn simplify(eles: &[f64], epsilon: f64) -> Vec<usize> {
let trkseg = segment(eles);
ramer_douglas_peucker(&trkseg, &|idx| (idx.flat as f64, trkseg[idx].ele), epsilon)
.iter()
.map(|idx| idx.flat)
.collect()
}
#[test]
fn test_empty_and_single_point() {
assert!(simplify(&[], 1.0).is_empty());
assert_eq!(simplify(&[5.0], 1.0), vec![0]);
}
#[test]
fn test_collinear_points_are_removed() {
let eles: Vec<f64> = (0..20).map(|i| i as f64 * 2.0).collect();
assert_eq!(simplify(&eles, 0.1), vec![0, 19]);
}
#[test]
fn test_peak_is_kept_when_above_epsilon() {
let eles = [0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 0.0];
assert_eq!(simplify(&eles, 5.0), vec![0, 3, 6]);
}
#[test]
fn test_peak_is_dropped_when_below_epsilon() {
let eles = [0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0];
assert_eq!(simplify(&eles, 1.0), vec![0, 6]);
}
#[test]
fn test_indices_are_sorted_and_keep_extremities() {
let eles = [0.0, 5.0, -3.0, 8.0, 1.0, 9.0, -4.0, 2.0, 7.0, 0.0];
let kept = simplify(&eles, 0.5);
assert_eq!(kept.first(), Some(&0));
assert_eq!(kept.last(), Some(&9));
assert!(kept.windows(2).all(|w| w[0] < w[1]));
// a larger epsilon never keeps more points
assert!(simplify(&eles, 5.0).len() <= kept.len());
}
}
File renamed without changes.
+100
View File
@@ -0,0 +1,100 @@
use uuid::Uuid;
use crate::{Trackpoint, Waypoint};
const MAX_TRKPT_CHUNK_SIZE: usize = 4096;
#[derive(Debug, PartialEq, Eq)]
pub struct TrackpointChunkId(Uuid);
impl Default for TrackpointChunkId {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
#[derive(Debug, Default)]
pub struct TrackpointChunk {
pub id: TrackpointChunkId,
pub trkpt: Vec<Trackpoint>,
}
impl PartialEq for TrackpointChunk {
fn eq(&self, other: &Self) -> bool {
self.id == other.id
}
}
impl TrackpointChunk {
pub fn is_full(&self) -> bool {
self.trkpt.len() == MAX_TRKPT_CHUNK_SIZE
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WaypointChunkId(Uuid);
impl Default for WaypointChunkId {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
const MAX_WPT_CHUNK_SIZE: usize = 128;
#[derive(Debug, Default)]
pub struct WaypointChunk {
pub id: WaypointChunkId,
pub wpt: Vec<Waypoint>,
}
impl PartialEq for WaypointChunk {
fn eq(&self, other: &Self) -> bool {
self.id == other.id
}
}
impl WaypointChunk {
pub fn is_full(&self) -> bool {
self.wpt.len() == MAX_WPT_CHUNK_SIZE
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_trackpoint_chunk_full() {
let mut chunk = TrackpointChunk::default();
assert!(!chunk.is_full());
for _ in 0..MAX_TRKPT_CHUNK_SIZE - 1 {
chunk.trkpt.push(Trackpoint::default());
}
assert!(!chunk.is_full());
chunk.trkpt.push(Trackpoint::default());
assert!(chunk.is_full());
}
#[test]
fn test_waypoint_chunk_full() {
let mut chunk = WaypointChunk::default();
assert!(!chunk.is_full());
for _ in 0..MAX_WPT_CHUNK_SIZE {
chunk.wpt.push(Waypoint::default());
}
assert!(chunk.is_full());
}
#[test]
fn test_chunk_equality_is_by_id() {
let a = TrackpointChunk::default();
let b = TrackpointChunk::default();
assert_ne!(a, b);
let c = TrackpointChunk {
id: TrackpointChunkId(a.id.0),
trkpt: vec![Trackpoint::default()],
};
assert_eq!(a, c);
}
}
@@ -1,20 +1,3 @@
/// Defines an identifier made of a UUID, which is a new one by default.
macro_rules! uuid_id {
($(#[$meta:meta])* $name:ident) => {
$(#[$meta])*
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct $name(pub uuid::Uuid);
impl Default for $name {
fn default() -> Self {
Self(uuid::Uuid::new_v4())
}
}
};
}
pub(crate) use uuid_id;
#[derive(Debug, Default, Clone, PartialEq, Eq)] #[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct Link { pub struct Link {
pub href: String, pub href: String,
+49
View File
@@ -0,0 +1,49 @@
use std::rc::Rc;
use uuid::Uuid;
use crate::{Link, Track, WaypointChunk};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct FileId(pub Uuid);
impl Default for FileId {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct FileWaypointsRevisionId(pub Uuid);
impl Default for FileWaypointsRevisionId {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
#[derive(Debug, Default, Clone, PartialEq)]
pub struct File {
pub id: FileId,
pub info: FileInfo,
pub trk: Vec<Track>,
pub wpt: Vec<Rc<WaypointChunk>>,
pub wpt_rev_id: FileWaypointsRevisionId,
// TODO routes
}
#[derive(Debug, Default, Clone, PartialEq)]
pub struct FileInfo {
pub name: String,
pub desc: Option<String>,
pub author: Option<Author>,
pub link: Option<Link>,
pub time: Option<i64>,
}
#[derive(Debug, Default, Clone, PartialEq)]
pub struct Author {
pub name: Option<String>,
pub email: Option<String>,
pub link: Option<Link>,
}
@@ -1,23 +1,17 @@
mod categories; mod categories;
mod chunk; mod chunk;
mod chunked;
mod common; mod common;
mod file; mod file;
mod route;
mod segment; mod segment;
mod track; mod track;
mod trackpoint; mod trackpoint;
mod waypoint; mod waypoint;
mod waypoints;
pub use categories::*; pub use categories::*;
pub use chunk::*; pub use chunk::*;
pub use chunked::*;
pub use common::*; pub use common::*;
pub use file::*; pub use file::*;
pub use route::*;
pub use segment::*; pub use segment::*;
pub use track::*; pub use track::*;
pub use trackpoint::*; pub use trackpoint::*;
pub use waypoint::*; pub use waypoint::*;
pub use waypoints::*;
+454
View File
@@ -0,0 +1,454 @@
use std::{ops::Index, rc::Rc};
use uuid::Uuid;
use crate::{Trackpoint, TrackpointChunk};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TrackSegmentId(pub Uuid);
impl Default for TrackSegmentId {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TrackSegmentRevisionId(pub Uuid);
impl Default for TrackSegmentRevisionId {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
#[derive(Debug, Default, Clone, PartialEq)]
pub struct TrackSegment {
pub id: TrackSegmentId,
pub rev_id: TrackSegmentRevisionId,
chunks: Vec<Rc<TrackpointChunk>>,
cumul_length: Vec<usize>,
}
impl TrackSegment {
pub fn push(&mut self, chunk: TrackpointChunk) {
self.push_shared(Rc::new(chunk));
}
fn push_shared(&mut self, chunk: Rc<TrackpointChunk>) {
if chunk.trkpt.is_empty() {
return;
}
self.cumul_length
.push(self.cumul_length.last().copied().unwrap_or_default() + chunk.trkpt.len());
self.chunks.push(chunk);
}
/// Replaces the points in `start..end` by `points`. Panics if the range is out of bounds.
///
/// Chunks that are not concerned are kept as they are (shared), only the chunks around the
/// range are copied and refilled.
pub fn splice(&mut self, start: usize, end: usize, points: Vec<Trackpoint>) {
assert!(
start <= end && end <= self.len(),
"splice range out of bounds"
);
let old = std::mem::take(&mut self.chunks);
self.cumul_length.clear();
let mut pending = TrackpointChunk::default();
let mut inserted = false;
let mut offset = 0;
for chunk in old {
let (lo, hi) = (offset, offset + chunk.trkpt.len());
offset = hi;
// a chunk ending at `start` is extended unless it is full, to avoid tiny chunks
if hi < start || (hi == start && chunk.is_full()) {
self.push_shared(chunk);
continue;
}
if !inserted {
self.fill(&mut pending, chunk.trkpt[..start - lo].iter().cloned());
self.fill(&mut pending, points.iter().cloned());
inserted = true;
}
if hi <= end {
continue;
}
if lo >= end {
self.flush(&mut pending);
self.push_shared(chunk);
} else {
self.fill(&mut pending, chunk.trkpt[end - lo..].iter().cloned());
}
}
if !inserted {
self.fill(&mut pending, points);
}
self.flush(&mut pending);
}
fn fill(
&mut self,
pending: &mut TrackpointChunk,
points: impl IntoIterator<Item = Trackpoint>,
) {
for trkpt in points {
pending.trkpt.push(trkpt);
if pending.is_full() {
self.flush(pending);
}
}
}
fn flush(&mut self, pending: &mut TrackpointChunk) {
self.push(std::mem::take(pending));
}
pub fn len(&self) -> usize {
self.cumul_length.last().copied().unwrap_or_default()
}
pub fn is_empty(&self) -> bool {
self.chunks.is_empty()
}
pub fn iter(&self) -> TrackSegmentIterator<'_> {
TrackSegmentIterator::new(self)
}
pub fn first_index(&self) -> Option<TrackSegmentIndex> {
self.next_index(None)
}
pub fn last_index(&self) -> Option<TrackSegmentIndex> {
self.prev_index(None)
}
pub fn next_index(&self, cur: Option<TrackSegmentIndex>) -> Option<TrackSegmentIndex> {
let mut next = cur.map_or_default(|idx| TrackSegmentIndex {
chunk: idx.chunk,
pos: idx.pos + 1,
flat: idx.flat + 1,
});
loop {
if next.chunk >= self.chunks.len() {
return None;
}
if next.pos == self.chunks[next.chunk].trkpt.len() {
next.chunk += 1;
next.pos = 0;
} else {
return Some(next);
}
}
}
pub fn prev_index(&self, cur: Option<TrackSegmentIndex>) -> Option<TrackSegmentIndex> {
let mut prev = cur.unwrap_or(TrackSegmentIndex {
chunk: self.chunks.len(),
pos: 0,
flat: self.cumul_length.last().copied().unwrap_or_default(),
});
if prev.pos == 0 {
while prev.chunk > 0 {
prev.chunk -= 1;
if !self.chunks[prev.chunk].trkpt.is_empty() {
prev.pos = self.chunks[prev.chunk].trkpt.len() - 1;
prev.flat -= 1;
return Some(prev);
}
}
None
} else {
prev.pos -= 1;
prev.flat -= 1;
Some(prev)
}
}
fn locate(&self, idx: usize) -> Option<TrackSegmentIndex> {
let chunk = self.cumul_length.partition_point(|l| idx >= *l);
if chunk >= self.chunks.len() {
return None;
}
let pos = if chunk > 0 {
idx - self.cumul_length[chunk - 1]
} else {
idx
};
if pos >= self.chunks[chunk].trkpt.len() {
None
} else {
Some(TrackSegmentIndex {
chunk,
pos,
flat: idx,
})
}
}
}
impl Index<TrackSegmentIndex> for TrackSegment {
type Output = Trackpoint;
fn index(&self, idx: TrackSegmentIndex) -> &Self::Output {
&self.chunks[idx.chunk].trkpt[idx.pos]
}
}
impl Index<usize> for TrackSegment {
type Output = Trackpoint;
fn index(&self, idx: usize) -> &Self::Output {
&self[self.locate(idx).unwrap()]
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, PartialOrd, Ord)]
pub struct TrackSegmentIndex {
pub chunk: usize,
pub pos: usize,
pub flat: usize,
}
#[derive(Debug, Clone)]
pub struct TrackSegmentIterator<'a> {
trkseg: &'a TrackSegment,
idx: Option<TrackSegmentIndex>,
}
impl<'a> TrackSegmentIterator<'a> {
pub fn new(trkseg: &'a TrackSegment) -> Self {
Self {
trkseg,
idx: Default::default(),
}
}
}
impl<'a> Iterator for TrackSegmentIterator<'a> {
type Item = &'a Trackpoint;
fn next(&mut self) -> Option<Self::Item> {
self.idx = self.trkseg.next_index(self.idx);
self.idx.map(|idx| &self.trkseg[idx])
}
fn nth(&mut self, n: usize) -> Option<Self::Item> {
let idx = self.idx.map_or_default(|idx| idx.flat) + n;
self.idx = self.trkseg.locate(idx);
self.idx.map(|idx| &self.trkseg[idx])
}
}
#[cfg(test)]
mod tests {
use super::*;
fn create_track_segment(nb_chunks: usize) -> TrackSegment {
let mut trkseg = TrackSegment::default();
let mut count = 0;
for n in 1..=nb_chunks {
let mut chunk = TrackpointChunk::default();
for _ in 0..n {
chunk.trkpt.push(Trackpoint {
ele: count as f64,
..Default::default()
});
count += 1;
}
trkseg.push(chunk);
}
trkseg
}
fn eles(trkseg: &TrackSegment) -> Vec<f64> {
trkseg.iter().map(|p| p.ele).collect()
}
fn points(eles: &[f64]) -> Vec<Trackpoint> {
eles.iter()
.map(|&ele| Trackpoint {
ele,
..Default::default()
})
.collect()
}
#[test]
fn test_splice_replace_insert_delete_append() {
// chunks of 1..=5 points: [0] [1 2] [3 4 5] [6 7 8 9] [10..=14]
let mut trkseg = create_track_segment(5);
trkseg.splice(4, 8, points(&[-1.0, -2.0]));
let mut expected: Vec<f64> = (0..4).map(f64::from).collect();
expected.extend([-1.0, -2.0]);
expected.extend((8..15).map(f64::from));
assert_eq!(eles(&trkseg), expected);
assert_eq!(trkseg.len(), expected.len());
for i in 0..trkseg.len() {
assert_eq!(trkseg[i].ele, expected[i]);
}
trkseg.splice(2, 2, points(&[100.0]));
expected.insert(2, 100.0);
assert_eq!(eles(&trkseg), expected);
trkseg.splice(0, 3, vec![]);
expected.drain(..3);
assert_eq!(eles(&trkseg), expected);
let len = trkseg.len();
trkseg.splice(len, len, points(&[7.0, 8.0]));
expected.extend([7.0, 8.0]);
assert_eq!(eles(&trkseg), expected);
let len = trkseg.len();
trkseg.splice(0, len, vec![]);
assert_eq!(trkseg.len(), 0);
assert!(trkseg.first_index().is_none());
}
#[test]
fn test_splice_keeps_untouched_chunks_shared() {
let mut trkseg = create_track_segment(5);
let before = trkseg.chunks.clone();
// inside the third chunk only
trkseg.splice(4, 5, points(&[-1.0]));
assert!(Rc::ptr_eq(&trkseg.chunks[0], &before[0]));
assert!(Rc::ptr_eq(&trkseg.chunks[1], &before[1]));
assert!(Rc::ptr_eq(trkseg.chunks.last().unwrap(), &before[4]));
assert!(Rc::ptr_eq(
&trkseg.chunks[trkseg.chunks.len() - 2],
&before[3]
));
}
#[test]
fn test_splice_append_extends_last_chunk_and_respects_max_size() {
let mut trkseg = TrackSegment::default();
for i in 0..10_000 {
let len = trkseg.len();
trkseg.splice(len, len, points(&[i as f64]));
}
assert_eq!(trkseg.len(), 10_000);
assert!(trkseg.chunks.len() <= 3);
assert!(trkseg.chunks.iter().all(|c| c.trkpt.len() <= 4096));
assert_eq!(trkseg[9_999].ele, 9_999.0);
assert_eq!(*trkseg.cumul_length.last().unwrap(), 10_000);
}
#[test]
fn test_len() {
let nb_chunks = 10;
let trkseg = create_track_segment(nb_chunks);
assert_eq!(trkseg.len(), nb_chunks * (nb_chunks + 1) / 2);
}
#[test]
fn test_locate() {
let nb_chunks = 10;
let trkseg = create_track_segment(nb_chunks);
for i in 0..trkseg.len() {
let idx = trkseg.locate(i);
assert!(idx.is_some());
assert_eq!(trkseg[idx.unwrap()].ele, i as f64);
}
assert!(trkseg.locate(trkseg.len()).is_none());
}
#[test]
fn test_index() {
let nb_chunks = 10;
let trkseg = create_track_segment(nb_chunks);
for i in 0..trkseg.len() {
assert_eq!(trkseg[i].ele, i as f64);
}
}
#[test]
#[should_panic]
fn test_index_out_of_bounds_1() {
let nb_chunks = 10;
let trkseg = create_track_segment(nb_chunks);
let _ = trkseg[trkseg.len()];
}
#[test]
#[should_panic]
fn test_index_out_of_bounds_2() {
let nb_chunks = 10;
let trkseg = create_track_segment(nb_chunks);
let _ = trkseg[TrackSegmentIndex {
chunk: trkseg.chunks.len(),
pos: 0,
flat: 0,
}];
}
#[test]
fn test_iter() {
let nb_chunks = 10;
let trkseg = create_track_segment(nb_chunks);
for (i, trkpt) in trkseg.iter().enumerate() {
assert!(std::ptr::eq(&trkseg[i], trkpt));
}
}
#[test]
fn test_iter_nth() {
let nb_chunks = 10;
let trkseg = create_track_segment(nb_chunks);
let tenth = trkseg.iter().nth(10);
assert!(tenth.is_some());
assert!(std::ptr::eq(&trkseg[10], tenth.unwrap()));
}
#[test]
fn test_iter_skip() {
let nb_chunks = 10;
let trkseg = create_track_segment(nb_chunks);
for (i, trkpt) in trkseg.iter().enumerate().skip(5) {
assert!(std::ptr::eq(&trkseg[i], trkpt));
}
}
#[test]
fn test_first_last_index() {
assert!(TrackSegment::default().first_index().is_none());
assert!(TrackSegment::default().last_index().is_none());
let trkseg = create_track_segment(5); // 15 points in chunks of 1..=5
let first = trkseg.first_index().unwrap();
let last = trkseg.last_index().unwrap();
assert_eq!((first.chunk, first.pos, first.flat), (0, 0, 0));
assert_eq!((last.chunk, last.pos, last.flat), (4, 4, 14));
assert_eq!(trkseg[last].ele, 14.0);
assert_eq!(trkseg.locate(14), Some(last));
assert!(trkseg.next_index(Some(last)).is_none());
assert!(trkseg.prev_index(Some(first)).is_none());
}
#[test]
fn test_prev_next_are_inverse() {
let trkseg = create_track_segment(6);
let mut idx = trkseg.last_index();
let mut visited = vec![];
while let Some(i) = idx {
assert_eq!(trkseg.locate(i.flat), Some(i));
visited.push(i.flat);
idx = trkseg.prev_index(Some(i));
}
assert_eq!(visited, (0..trkseg.len()).rev().collect::<Vec<_>>());
let mut idx = trkseg.first_index();
while let Some(i) = idx {
let next = trkseg.next_index(Some(i));
if let Some(n) = next {
assert_eq!(trkseg.prev_index(Some(n)), Some(i));
}
idx = next;
}
}
}
@@ -1,10 +1,17 @@
use uuid::Uuid;
use crate::{Link, TrackSegment}; use crate::{Link, TrackSegment};
use super::common::uuid_id; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TrackId(pub Uuid);
uuid_id!(TrackId); impl Default for TrackId {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
#[derive(Debug, Default, Clone)] #[derive(Debug, Default, Clone, PartialEq)]
pub struct Track { pub struct Track {
pub id: TrackId, pub id: TrackId,
pub info: TrackInfo, pub info: TrackInfo,
@@ -17,7 +24,7 @@ pub struct TrackInfo {
pub cmt: Option<String>, pub cmt: Option<String>,
pub desc: Option<String>, pub desc: Option<String>,
pub src: Option<String>, pub src: Option<String>,
pub links: Vec<Link>, pub link: Option<Link>,
pub type_: Option<String>, pub type_: Option<String>,
pub color: Option<String>, pub color: Option<String>,
pub opacity: Option<f64>, pub opacity: Option<f64>,
@@ -17,8 +17,4 @@ pub struct Trackpoint {
pub sac_scale: Option<u8>, pub sac_scale: Option<u8>,
/// Code of the mountain biking scale, see [`crate::TrackpointCategories`]. /// Code of the mountain biking scale, see [`crate::TrackpointCategories`].
pub mtb_scale: Option<u8>, pub mtb_scale: Option<u8>,
/// Whether the trackpoint is an anchor of the routing tool (a point the user can drag to
/// reroute the segment): the lowest map zoom level at which it is shown. The first and last
/// trackpoints of a segment are always anchors that are always shown (zoom 0).
pub anchor: Option<u8>,
} }
+26
View File
@@ -0,0 +1,26 @@
use uuid::Uuid;
use crate::{Link, LngLat};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct WaypointId(pub Uuid);
impl Default for WaypointId {
fn default() -> Self {
Self(Uuid::new_v4())
}
}
#[derive(Debug, Default, Clone)]
pub struct Waypoint {
pub id: WaypointId,
pub coordinates: LngLat,
pub ele: f64,
pub time: Option<i64>,
pub name: Option<String>,
pub cmt: Option<String>,
pub desc: Option<String>,
pub link: Option<Link>,
pub sym: Option<String>,
pub type_: Option<String>,
}
@@ -1,5 +1,3 @@
mod parse; mod parse;
mod write;
pub use parse::*; pub use parse::*;
pub use write::*;
+757
View File
@@ -0,0 +1,757 @@
use std::rc::Rc;
use crate::{
Author, File, Link, LngLat, Track, TrackSegment, Trackpoint, TrackpointCategories,
TrackpointChunk, Waypoint, WaypointChunk,
};
use chrono::DateTime;
use quick_xml::Error;
use quick_xml::events::Event;
use quick_xml::events::attributes::Attributes;
use quick_xml::reader::Reader;
enum GPXElement {
Metadata,
Name,
Comment,
Description,
Source,
Author(Author),
Link(Link),
Text,
Track(Track),
Segment(TrackSegment),
Trackpoint(Trackpoint),
Waypoint(Waypoint),
Elevation,
Time,
Temperature,
Heartrate,
Cadence,
Power,
Surface,
Highway,
SacScale,
MtbScale,
Symbol,
Type,
Color,
Opacity,
Width,
}
fn parse_coordinates(attributes: Attributes<'_>) -> LngLat {
let mut coordinates = LngLat::default();
for attr in attributes.flatten() {
match attr.key.as_ref() {
"lat" => coordinates.lat = attr.value.parse().unwrap_or_default(),
"lon" => coordinates.lng = attr.value.parse().unwrap_or_default(),
_ => (),
}
}
coordinates
}
/// Parses a GPX file. The surface, highway, SAC scale and MTB scale of the trackpoints are stored as codes of
/// `categories`, which learns the values it does not know yet.
pub fn parse(data: &[u8], categories: &mut TrackpointCategories) -> Result<File, Error> {
let mut reader = Reader::from_reader(data);
let mut buf = vec![];
let mut gpx = File::default();
let mut stack: Vec<GPXElement> = vec![];
let mut trkpt_chunk = TrackpointChunk::default();
let mut wpt_chunk = WaypointChunk::default();
loop {
match reader.read_event_into(&mut buf) {
Ok(Event::Start(e)) => match e.name().as_ref() {
"metadata" => stack.push(GPXElement::Metadata),
"name" => stack.push(GPXElement::Name),
"cmt" => stack.push(GPXElement::Comment),
"desc" => stack.push(GPXElement::Description),
"src" => stack.push(GPXElement::Source),
"author" => stack.push(GPXElement::Author(Author::default())),
"link" => {
let mut link = Link::default();
for attr in e.attributes().flatten() {
if attr.key.as_ref() == "href" {
link.href = attr.value.to_string();
}
}
stack.push(GPXElement::Link(link));
}
"text" => stack.push(GPXElement::Text),
"trk" => stack.push(GPXElement::Track(Track::default())),
"trkseg" => {
stack.push(GPXElement::Segment(TrackSegment::default()));
}
"trkpt" => {
stack.push(GPXElement::Trackpoint(Trackpoint {
coordinates: parse_coordinates(e.attributes()),
..Default::default()
}));
}
"wpt" => {
stack.push(GPXElement::Waypoint(Waypoint {
coordinates: parse_coordinates(e.attributes()),
..Default::default()
}));
}
"ele" => stack.push(GPXElement::Elevation),
"time" => stack.push(GPXElement::Time),
e if e.ends_with("atemp") => stack.push(GPXElement::Temperature),
e if e.ends_with("hr") => stack.push(GPXElement::Heartrate),
e if e.ends_with("cad") => stack.push(GPXElement::Cadence),
e if e.ends_with("power") => stack.push(GPXElement::Power),
e if e.ends_with("PowerInWatts") => stack.push(GPXElement::Power),
"surface" => stack.push(GPXElement::Surface),
"highway" => stack.push(GPXElement::Highway),
"sac_scale" => stack.push(GPXElement::SacScale),
"mtb_scale" => stack.push(GPXElement::MtbScale),
"sym" => stack.push(GPXElement::Symbol),
"type" => stack.push(GPXElement::Type),
e if e.ends_with("color") => stack.push(GPXElement::Color),
e if e.ends_with("opacity") => stack.push(GPXElement::Opacity),
e if e.ends_with("width") => stack.push(GPXElement::Width),
_ => (),
},
// Self-closing points (`<trkpt lat=".." lon=".."/>`), which have no children
Ok(Event::Empty(e)) => match e.name().as_ref() {
"trkpt" => {
if let Some(GPXElement::Segment(trkseg)) = stack.last_mut() {
trkpt_chunk.trkpt.push(Trackpoint {
coordinates: parse_coordinates(e.attributes()),
..Default::default()
});
if trkpt_chunk.is_full() {
trkseg.push(std::mem::take(&mut trkpt_chunk));
}
}
}
"wpt" => {
wpt_chunk.wpt.push(Waypoint {
coordinates: parse_coordinates(e.attributes()),
..Default::default()
});
if wpt_chunk.is_full() {
gpx.wpt.push(Rc::new(std::mem::take(&mut wpt_chunk)));
}
}
_ => (),
},
Ok(Event::End(e)) => match e.name().as_ref() {
"gpx" => {
if !wpt_chunk.wpt.is_empty() {
gpx.wpt.push(Rc::new(std::mem::take(&mut wpt_chunk)));
}
}
"metadata" => {
stack.pop();
}
"author" => {
if let Some(GPXElement::Author(author)) = stack.pop() {
gpx.info.author = Some(author);
}
}
"link" => {
if let Some(GPXElement::Link(link)) = stack.pop() {
match stack.last_mut() {
Some(GPXElement::Author(author)) => {
author.link = Some(link);
}
Some(GPXElement::Track(trk)) => {
trk.info.link = Some(link);
}
Some(GPXElement::Waypoint(wpt)) => {
wpt.link = Some(link);
}
_ => (),
}
}
}
"trk" => {
if let Some(GPXElement::Track(trk)) = stack.pop() {
gpx.trk.push(trk);
}
}
"trkseg" => {
if let Some(GPXElement::Segment(mut trkseg)) = stack.pop()
&& let Some(GPXElement::Track(trk)) = stack.last_mut()
{
// `push` ignores the chunk if it is empty
trkseg.push(std::mem::take(&mut trkpt_chunk));
trk.trkseg.push(trkseg);
}
}
"trkpt" => {
if let Some(GPXElement::Trackpoint(trkpt)) = stack.pop()
&& let Some(GPXElement::Segment(trkseg)) = stack.last_mut()
{
trkpt_chunk.trkpt.push(trkpt);
if trkpt_chunk.is_full() {
trkseg.push(std::mem::take(&mut trkpt_chunk));
}
}
}
"wpt" => {
if let Some(GPXElement::Waypoint(wpt)) = stack.pop() {
wpt_chunk.wpt.push(wpt);
if wpt_chunk.is_full() {
gpx.wpt.push(Rc::new(std::mem::take(&mut wpt_chunk)));
}
}
}
_ => (),
},
Ok(Event::Text(e)) => match stack.last_mut() {
Some(GPXElement::Name) => {
stack.pop();
match stack.last_mut() {
Some(GPXElement::Metadata) => {
gpx.info.name = e.to_string();
}
Some(GPXElement::Author(author)) => {
author.name = Some(e.to_string());
}
Some(GPXElement::Track(trk)) => {
trk.info.name = Some(e.to_string());
}
Some(GPXElement::Waypoint(wpt)) => {
wpt.name = Some(e.to_string());
}
_ => (),
}
}
Some(GPXElement::Comment) => {
stack.pop();
match stack.last_mut() {
Some(GPXElement::Track(trk)) => {
trk.info.cmt = Some(e.to_string());
}
Some(GPXElement::Waypoint(wpt)) => {
wpt.cmt = Some(e.to_string());
}
_ => (),
}
}
Some(GPXElement::Description) => {
stack.pop();
match stack.last_mut() {
Some(GPXElement::Metadata) => {
gpx.info.desc = Some(e.to_string());
}
Some(GPXElement::Track(trk)) => {
trk.info.desc = Some(e.to_string());
}
Some(GPXElement::Waypoint(wpt)) => {
wpt.desc = Some(e.to_string());
}
_ => (),
}
}
Some(GPXElement::Source) => {
stack.pop();
if let Some(GPXElement::Track(trk)) = stack.last_mut() {
trk.info.src = Some(e.to_string());
}
}
Some(GPXElement::Text) => {
stack.pop();
if let Some(GPXElement::Link(link)) = stack.last_mut() {
link.text = Some(e.to_string());
}
}
Some(GPXElement::Elevation) => {
stack.pop();
match stack.last_mut() {
Some(GPXElement::Trackpoint(trkpt)) => {
trkpt.ele = e.parse().unwrap_or_default();
}
Some(GPXElement::Waypoint(wpt)) => {
wpt.ele = e.parse().unwrap_or_default();
}
_ => (),
}
}
Some(GPXElement::Time) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.time = DateTime::parse_from_rfc3339(e.as_ref())
.ok()
.map(|time| time.timestamp_millis());
}
}
Some(GPXElement::Temperature) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.atemp = e.parse().ok();
}
}
Some(GPXElement::Heartrate) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.hr = e.parse().ok();
}
}
Some(GPXElement::Cadence) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.cad = e.parse().ok();
}
}
Some(GPXElement::Power) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.power = e.parse().ok();
}
}
Some(GPXElement::Surface) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.surface = categories.surface.code(&e);
}
}
Some(GPXElement::Highway) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.highway = categories.highway.code(&e);
}
}
Some(GPXElement::SacScale) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.sac_scale = categories.sac_scale.code(&e);
}
}
Some(GPXElement::MtbScale) => {
stack.pop();
if let Some(GPXElement::Trackpoint(trkpt)) = stack.last_mut() {
trkpt.mtb_scale = categories.mtb_scale.code(&e);
}
}
Some(GPXElement::Symbol) => {
stack.pop();
if let Some(GPXElement::Waypoint(wpt)) = stack.last_mut() {
wpt.sym = Some(e.to_string());
}
}
Some(GPXElement::Type) => {
stack.pop();
match stack.last_mut() {
Some(GPXElement::Track(trk)) => {
trk.info.type_ = Some(e.to_string());
}
Some(GPXElement::Waypoint(wpt)) => {
wpt.type_ = Some(e.to_string());
}
_ => (),
}
}
Some(GPXElement::Color) => {
stack.pop();
if let Some(GPXElement::Track(trk)) = stack.last_mut() {
trk.info.color = Some(e.to_string());
}
}
Some(GPXElement::Opacity) => {
stack.pop();
if let Some(GPXElement::Track(trk)) = stack.last_mut() {
trk.info.opacity = e.parse().ok();
}
}
Some(GPXElement::Width) => {
stack.pop();
if let Some(GPXElement::Track(trk)) = stack.last_mut() {
trk.info.width = e.parse().ok();
}
}
_ => (),
},
Ok(Event::Eof) => break,
Err(e) => return Err(e),
_ => (),
}
buf.clear();
}
Ok(gpx)
}
#[cfg(test)]
mod tests {
use super::*;
fn parse_data(name: &str) -> File {
parse(
&std::fs::read(format!("data/{name}.gpx")).unwrap(),
&mut Default::default(),
)
.unwrap()
}
#[test]
fn test_parse_self_closing_points() {
let gpx = parse_data("self_closing_points");
assert_eq!(gpx.info.name, "self closing points");
let wpt: Vec<_> = gpx.wpt.iter().flat_map(|chunk| &chunk.wpt).collect();
assert_eq!(wpt.len(), 3);
assert_eq!(wpt[0].coordinates.lat, 50.0);
assert_eq!(wpt[0].name, None);
assert_eq!(wpt[1].name.as_deref(), Some("with children"));
assert_eq!(wpt[2].coordinates.lng, 4.2);
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 2);
let seg = &trk.trkseg[0];
assert_eq!(seg.len(), 3);
assert_eq!(seg[0].coordinates.lat, 50.0);
assert_eq!(seg[0].ele, 0.0);
assert_eq!(seg[1].ele, 12.5);
assert_eq!(seg[2].coordinates.lng, 4.02);
assert_eq!(trk.trkseg[1].len(), 1);
}
#[test]
fn test_parse_simple() {
let gpx = parse_data("simple");
assert_eq!(gpx.info.name, "simple");
assert!(gpx.info.desc.is_some_and(|d| d == "description"));
assert!(gpx.info.author.is_some());
let author = gpx.info.author.as_ref().unwrap();
assert!(author.name.as_ref().is_some_and(|n| n == "gpx.studio"));
assert!(author.link.is_some());
let link = author.link.as_ref().unwrap();
assert_eq!(link.href, "https://gpx.studio");
assert!(link.text.as_ref().is_some_and(|t| t == "link text"));
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert!(trk.info.name.as_ref().is_some_and(|n| n == "track name"));
assert!(trk.info.cmt.as_ref().is_some_and(|c| c == "track comment"));
assert!(
trk.info
.desc
.as_ref()
.is_some_and(|d| d == "track description")
);
assert!(trk.info.src.as_ref().is_some_and(|s| s == "track source"));
assert!(trk.info.link.is_some());
let link = trk.info.link.as_ref().unwrap();
assert_eq!(link.href, "https://gpx.studio");
assert!(link.text.as_ref().is_some_and(|t| t == "track link text"));
assert!(trk.info.type_.as_ref().is_some_and(|c| c == "Cycling"));
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert_eq!(trkseg.len(), 80);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.790867);
assert_eq!(trkpt.coordinates.lng, 4.404968);
assert_eq!(trkpt.ele, 109.0);
}
#[test]
fn test_parse_tracks() {
let gpx = parse_data("with_tracks");
assert_eq!(gpx.trk.len(), 2);
let trk = &gpx.trk[0];
assert!(trk.info.name.as_ref().is_some_and(|n| n == "track 1"));
assert!(trk.info.type_.as_ref().is_some_and(|c| c == "Cycling"));
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert_eq!(trkseg.len(), 49);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.790867);
assert_eq!(trkpt.coordinates.lng, 4.404968);
assert_eq!(trkpt.ele, 109.0);
let trk = &gpx.trk[1];
assert!(trk.info.name.as_ref().is_some_and(|n| n == "track 2"));
assert!(trk.info.type_.as_ref().is_some_and(|c| c == "Cycling"));
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert_eq!(trkseg.len(), 28);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.782212);
assert_eq!(trkpt.coordinates.lng, 4.406377);
assert_eq!(trkpt.ele, 115.5);
}
#[test]
fn test_parse_segments() {
let gpx = parse_data("with_segments");
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 2);
let trkseg = &trk.trkseg[0];
assert_eq!(trkseg.len(), 49);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.790867);
assert_eq!(trkpt.coordinates.lng, 4.404968);
assert_eq!(trkpt.ele, 109.0);
let trkseg = &trk.trkseg[1];
assert_eq!(trkseg.len(), 28);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.782212);
assert_eq!(trkpt.coordinates.lng, 4.406377);
assert_eq!(trkpt.ele, 115.5);
}
#[test]
fn test_parse_tracks_and_segments() {
let gpx = parse_data("with_tracks_and_segments");
assert_eq!(gpx.trk.len(), 2);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 2);
let trkseg = &trk.trkseg[0];
assert_eq!(trkseg.len(), 16);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.790867);
assert_eq!(trkpt.coordinates.lng, 4.404968);
assert_eq!(trkpt.ele, 109.0);
let trkseg = &trk.trkseg[1];
assert_eq!(trkseg.len(), 34);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.78727108169855);
assert_eq!(trkpt.coordinates.lng, 4.406133681127736);
assert_eq!(trkpt.ele, 115.0);
let trk = &gpx.trk[1];
assert_eq!(trk.trkseg.len(), 2);
let trkseg = &trk.trkseg[0];
assert_eq!(trkseg.len(), 19);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.782212);
assert_eq!(trkpt.coordinates.lng, 4.406377);
assert_eq!(trkpt.ele, 115.5);
let trkseg = &trk.trkseg[1];
assert_eq!(trkseg.len(), 10);
let trkpt = &trkseg[0];
assert_eq!(trkpt.coordinates.lat, 50.77906316558724);
assert_eq!(trkpt.coordinates.lng, 4.412547477922485);
assert_eq!(trkpt.ele, 133.3);
}
#[test]
fn test_parse_waypoint() {
let gpx = parse_data("with_waypoint");
assert_eq!(gpx.wpt.len(), 1);
let chunk = &gpx.wpt[0];
assert_eq!(chunk.wpt.len(), 1);
let wpt = &chunk.wpt[0];
assert_eq!(wpt.coordinates.lat, 50.7836710064975);
assert_eq!(wpt.coordinates.lng, 4.410764082658738);
assert!(wpt.name.as_ref().is_some_and(|n| n == "waypoint name"));
assert!(wpt.cmt.as_ref().is_some_and(|c| c == "waypoint comment"));
assert!(
wpt.desc
.as_ref()
.is_some_and(|d| d == "waypoint description")
);
assert!(wpt.link.is_some());
let link = wpt.link.as_ref().unwrap();
assert_eq!(link.href, "https://gpx.studio");
assert!(
link.text
.as_ref()
.is_some_and(|t| t == "waypoint link text")
);
assert!(wpt.sym.as_ref().is_some_and(|s| s == "Bike Trail"));
assert!(wpt.type_.as_ref().is_some_and(|t| t == "Bike Trail"));
}
#[test]
fn test_parse_trackpoint_time() {
let gpx = parse_data("with_time");
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert!(!trkseg.is_empty());
let trkpt = &trkseg[0];
assert!(trkpt.time.is_some_and(|t| t == 1704063600000));
}
#[test]
fn test_parse_trackpoint_hr() {
let gpx = parse_data("with_hr");
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert!(!trkseg.is_empty());
let trkpt = &trkseg[0];
assert!(trkpt.hr.is_some_and(|h| h == 150));
}
fn parse_data_with_categories(name: &str) -> (File, TrackpointCategories) {
let mut categories = TrackpointCategories::default();
let file = parse(
&std::fs::read(format!("data/{name}.gpx")).unwrap(),
&mut categories,
)
.unwrap();
(file, categories)
}
#[test]
fn test_parse_trackpoint_surface() {
let (gpx, categories) = parse_data_with_categories("with_surface");
let trkseg = &gpx.trk[0].trkseg[0];
assert_eq!(trkseg.len(), 80);
// the codes follow the order of appearance in the file
assert_eq!(categories.surface.names(), ["asphalt", "cobblestone"]);
let asphalt = Some(0);
let cobblestone = Some(1);
assert_eq!(trkseg.iter().filter(|p| p.surface == asphalt).count(), 79);
assert_eq!(
trkseg.iter().filter(|p| p.surface == cobblestone).count(),
1
);
// no highway in this file
assert!(trkseg.iter().all(|trkpt| trkpt.highway.is_none()));
assert!(categories.highway.names().is_empty());
}
#[test]
fn test_parse_trackpoint_surface_highway_and_scales() {
let (gpx, categories) = parse_data_with_categories("with_highway");
let trkseg = &gpx.trk[0].trkseg[0];
let names = |code: Option<u8>, names: &crate::Categories| {
code.and_then(|code| names.name(code)).map(str::to_owned)
};
let values: Vec<_> = trkseg
.iter()
.map(|trkpt| {
[
names(trkpt.surface, &categories.surface),
names(trkpt.highway, &categories.highway),
names(trkpt.sac_scale, &categories.sac_scale),
names(trkpt.mtb_scale, &categories.mtb_scale),
]
})
.collect();
let some = |s: &str| Some(s.to_owned());
assert_eq!(
values,
[
[some("asphalt"), some("residential"), None, None],
[some("asphalt"), some("residential"), None, None],
[None, None, None, None],
[
some("gravel"),
some("track"),
some("mountain_hiking"),
some("1")
],
[some("gravel"), None, some("hiking"), some("1")],
]
);
// the tables are separate
assert_eq!(categories.sac_scale.names(), ["mountain_hiking", "hiking"]);
assert_eq!(categories.mtb_scale.names(), ["1"]);
}
#[test]
fn test_parse_shares_the_categories_between_files() {
let mut categories = TrackpointCategories::default();
let mut parsed = |name: &str| {
parse(
&std::fs::read(format!("data/{name}.gpx")).unwrap(),
&mut categories,
)
.unwrap()
};
let first = parsed("with_highway");
let second = parsed("with_surface");
let code = |file: &File, i: usize| file.trk[0].trkseg[0][i].surface;
// "asphalt" is the same in both, "cobblestone" comes after "gravel"
assert_eq!(code(&first, 0), Some(0));
assert_eq!(code(&second, 0), Some(0));
assert_eq!(
categories.surface.names(),
["asphalt", "gravel", "cobblestone"]
);
}
#[test]
fn test_parse_trackpoint_cad() {
let gpx = parse_data("with_cad");
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert!(!trkseg.is_empty());
let trkpt = &trkseg[0];
assert!(trkpt.cad.is_some_and(|c| c == 80));
}
#[test]
fn test_parse_trackpoint_power_1() {
let gpx = parse_data("with_power_1");
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert!(!trkseg.is_empty());
let trkpt = &trkseg[0];
assert!(trkpt.power.is_some_and(|p| p == 200));
}
#[test]
fn test_parse_trackpoint_power_2() {
let gpx = parse_data("with_power_2");
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert!(!trkseg.is_empty());
let trkpt = &trkseg[0];
assert!(trkpt.power.is_some_and(|p| p == 200));
}
#[test]
fn test_parse_trackpoint_atemp() {
let gpx = parse_data("with_temp");
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 1);
let trkseg = &trk.trkseg[0];
assert!(!trkseg.is_empty());
let trkpt = &trkseg[0];
assert!(trkpt.atemp.is_some_and(|t| t == 21));
}
#[test]
fn test_parse_track_style() {
let gpx = parse_data("with_style");
assert_eq!(gpx.trk.len(), 1);
let trk = &gpx.trk[0];
assert_eq!(trk.trkseg.len(), 1);
assert!(trk.info.color.as_ref().is_some_and(|c| c == "2d3ee9"));
assert!(trk.info.opacity.is_some_and(|o| o == 0.5));
assert!(trk.info.width.is_some_and(|w| w == 6.0));
}
}
File renamed without changes.
+5
View File
@@ -0,0 +1,5 @@
mod statistics;
mod utils;
pub use statistics::*;
pub use utils::*;
@@ -3,20 +3,6 @@ use crate::{
max_options, min_options, ramer_douglas_peucker, slope, speed, sum_options, time_diff, max_options, min_options, ramer_douglas_peucker, slope, speed, sum_options, time_diff,
}; };
/// Time between two trackpoints, to size the windows of a smoothing. It is unknown when one of
/// them has no time, which is longer than any known time span: the window does not go there.
#[derive(Clone, Copy, PartialEq, PartialOrd)]
enum TimeSpan {
Known(i64),
Unknown,
}
impl TimeSpan {
fn between(end: Option<i64>, start: Option<i64>) -> Self {
time_diff(end, start).map_or(Self::Unknown, Self::Known)
}
}
#[derive(Default, Debug)] #[derive(Default, Debug)]
pub struct Statistics { pub struct Statistics {
pub global: GlobalStatistics, pub global: GlobalStatistics,
@@ -55,6 +41,10 @@ impl Statistics {
self.accumulate_distance_and_time(prev, cur); self.accumulate_distance_and_time(prev, cur);
self.update_time_bounds(cur.time); self.update_time_bounds(cur.time);
self.update_bounds(cur.coordinates); self.update_bounds(cur.coordinates);
self.global.hr.add(cur.hr.map(f64::from));
self.global.cad.add(cur.cad.map(f64::from));
self.global.atemp.add(cur.atemp.map(f64::from));
self.global.power.add(cur.power.map(f64::from));
self.local self.local
.push(TrackpointStatistics::from_partial_stats(self)); .push(TrackpointStatistics::from_partial_stats(self));
} }
@@ -65,18 +55,18 @@ impl Statistics {
self.global.total_distance += dist; self.global.total_distance += dist;
let moving = time if let Some(time) = time {
.zip(time.and_then(|time| speed(dist, time))) let speed = speed(dist, time);
.filter(|(_, speed)| (0.5..=1500.0).contains(speed)); if (0.5..=1500.0).contains(&speed) {
if let Some((time, _)) = moving { self.global.moving_distance = self
self.global.moving_distance = self .global
.global .moving_distance
.moving_distance .map_or(Some(dist), |d| Some(d + dist));
.map_or(Some(dist), |d| Some(d + dist)); self.global.moving_time = self
self.global.moving_time = self .global
.global .moving_time
.moving_time .map_or(Some(time), |t| Some(t + time));
.map_or(Some(time), |t| Some(t + time)); }
} }
} }
@@ -94,35 +84,22 @@ impl Statistics {
self.global.bounds.extend(coordinates); self.global.bounds.extend(coordinates);
} }
/// Speed over a window of 10 seconds on each side of the trackpoints that have a time (the
/// others have no speed). The windows do not extend to the trackpoints without time: if the
/// previous or next trackpoint has none, the window ends at the trackpoint itself on that side.
fn compute_smoothed_speed(&mut self, trkseg: &TrackSegment) { fn compute_smoothed_speed(&mut self, trkseg: &TrackSegment) {
for_each_window!( for_each_window!(
trkseg, trkseg,
trkseg.first_index(), trkseg.first_index(),
trkseg.last_index(), trkseg.last_index(),
TimeSpan::Known(10_000), Some(10_000),
|i, j| TimeSpan::between(trkseg[j].time, trkseg[i].time), |i, j| time_diff(trkseg[j].time, trkseg[i].time),
|i, left, right| { |i, left, right| {
if trkseg[i].time.is_some() { self.local[i.flat].speed =
let timed = |index: TrackSegmentIndex| { time_diff(trkseg[right].time, trkseg[left].time).map(|t| {
if trkseg[index].time.is_some() { speed(
index self.local[right.flat].total_distance
} else { - self.local[left.flat].total_distance,
i t,
} )
}; });
let (left, right) = (timed(left), timed(right));
self.local[i.flat].speed = time_diff(trkseg[right].time, trkseg[left].time)
.and_then(|time| {
speed(
self.local[right.flat].total_distance
- self.local[left.flat].total_distance,
time,
)
});
}
}, },
); );
} }
@@ -234,6 +211,32 @@ impl Statistics {
} }
} }
/// Average of an optional measure (heart rate, cadence...) over the trackpoints that have it.
/// Keeps the sum so that averages can be merged.
#[derive(Default, Debug, Clone, Copy, PartialEq)]
pub struct Average {
pub sum: f64,
pub count: u32,
}
impl Average {
pub fn add(&mut self, value: Option<f64>) {
if let Some(value) = value {
self.sum += value;
self.count += 1;
}
}
pub fn merge(&mut self, other: &Average) {
self.sum += other.sum;
self.count += other.count;
}
pub fn avg(&self) -> Option<f64> {
(self.count > 0).then(|| self.sum / self.count as f64)
}
}
#[derive(Default, Debug)] #[derive(Default, Debug)]
pub struct GlobalStatistics { pub struct GlobalStatistics {
pub total_distance: f64, pub total_distance: f64,
@@ -245,20 +248,21 @@ pub struct GlobalStatistics {
pub start_time: Option<i64>, pub start_time: Option<i64>,
pub end_time: Option<i64>, pub end_time: Option<i64>,
pub bounds: LngLatBounds, pub bounds: LngLatBounds,
pub hr: Average,
pub cad: Average,
pub atemp: Average,
pub power: Average,
} }
impl GlobalStatistics { impl GlobalStatistics {
/// Average speed over the total time, unknown if that is not a positive duration (for
/// example a range with a single timestamp, or timestamps going backwards).
pub fn total_speed(&self) -> Option<f64> { pub fn total_speed(&self) -> Option<f64> {
self.total_time.and_then(|t| speed(self.total_distance, t)) self.total_time.map(|t| speed(self.total_distance, t))
} }
/// Average speed over the moving time, unknown if there is no moving time.
pub fn moving_speed(&self) -> Option<f64> { pub fn moving_speed(&self) -> Option<f64> {
self.moving_distance self.moving_distance
.zip(self.moving_time) .zip(self.moving_time)
.and_then(|(d, t)| speed(d, t)) .map(|(d, t)| speed(d, t))
} }
pub fn merge(&mut self, other: &GlobalStatistics) { pub fn merge(&mut self, other: &GlobalStatistics) {
@@ -271,6 +275,10 @@ impl GlobalStatistics {
self.start_time = min_options(self.start_time, other.start_time); self.start_time = min_options(self.start_time, other.start_time);
self.end_time = max_options(self.end_time, other.end_time); self.end_time = max_options(self.end_time, other.end_time);
self.bounds.merge(&other.bounds); self.bounds.merge(&other.bounds);
self.hr.merge(&other.hr);
self.cad.merge(&other.cad);
self.atemp.merge(&other.atemp);
self.power.merge(&other.power);
} }
} }
@@ -336,83 +344,6 @@ mod tests {
} }
} }
/// The speeds of the segment of `data/with_time.gpx` (80 trackpoints at 20 km/h) once the
/// trackpoints at `holes` have lost their time.
fn speeds_with_holes(holes: &[usize]) -> Vec<Option<f64>> {
let gpx = load("data/with_time.gpx");
let mut segment = gpx.trk[0].trkseg[0].clone();
let points: Vec<_> = segment
.iter()
.enumerate()
.map(|(i, trkpt)| {
let mut trkpt = trkpt.clone();
if holes.contains(&i) {
trkpt.time = None;
}
trkpt
})
.collect();
segment.splice(0, points.len(), points);
Statistics::compute(&segment)
.local
.iter()
.map(|local| local.speed)
.collect()
}
/// Without time, there is no speed. With one, the speed is the one of the trackpoints around.
fn assert_speeds_with_holes(holes: &[usize]) {
let speeds = speeds_with_holes(holes);
assert_eq!(speeds.len(), 80);
for (i, speed) in speeds.iter().enumerate() {
if holes.contains(&i) {
assert_eq!(*speed, None, "trackpoint {i}");
} else {
let speed = speed.unwrap_or_else(|| panic!("no speed for trackpoint {i}"));
assert!((speed - 20.0).abs() < 0.1, "trackpoint {i}: {speed}");
}
}
}
#[test]
fn test_speed_without_holes() {
assert_speeds_with_holes(&[]);
}
#[test]
fn test_speed_with_holes_at_the_beginning() {
assert_speeds_with_holes(&[0, 1, 2, 3, 4]);
}
#[test]
fn test_speed_with_holes_at_the_end() {
assert_speeds_with_holes(&[75, 76, 77, 78, 79]);
}
#[test]
fn test_speed_with_holes_at_both_ends() {
assert_speeds_with_holes(&[0, 1, 2, 77, 78, 79]);
}
#[test]
fn test_speed_with_holes_in_the_middle() {
assert_speeds_with_holes(&[40]);
assert_speeds_with_holes(&[30, 31, 32, 33, 34]);
assert_speeds_with_holes(&(20..60).collect::<Vec<_>>());
}
#[test]
fn test_speed_with_scattered_holes() {
let holes: Vec<_> = (0..80).step_by(7).collect();
assert_speeds_with_holes(&holes);
}
#[test]
fn test_speed_without_any_time() {
let holes: Vec<_> = (0..80).collect();
assert!(speeds_with_holes(&holes).iter().all(Option::is_none));
}
fn load(path: &str) -> crate::File { fn load(path: &str) -> crate::File {
let mut f = File::open(path).unwrap(); let mut f = File::open(path).unwrap();
let mut data = String::new(); let mut data = String::new();
@@ -524,4 +455,50 @@ mod tests {
assert_eq!(cumul.total_time, Some(7_000)); assert_eq!(cumul.total_time, Some(7_000));
assert_eq!((a.bounds.ne.lng, a.bounds.ne.lat), (2.0, 3.0)); assert_eq!((a.bounds.ne.lng, a.bounds.ne.lat), (2.0, 3.0));
} }
#[test]
fn test_average() {
let mut average = Average::default();
assert_eq!(average.avg(), None);
average.add(None);
assert_eq!(average.avg(), None);
average.add(Some(100.0));
average.add(Some(110.0));
assert_eq!(average.avg(), Some(105.0));
let mut other = Average::default();
other.add(Some(130.0));
average.merge(&other);
assert_eq!(average.count, 3);
assert_eq!(average.avg(), Some(113.33333333333333));
}
#[test]
fn test_measures_of_the_trackpoints_are_averaged() {
for (path, measure) in [
("data/with_hr.gpx", 0),
("data/with_cad.gpx", 1),
("data/with_temp.gpx", 2),
("data/with_power_1.gpx", 3),
] {
let data = std::fs::read(path).unwrap();
let gpx = parse(&data, &mut Default::default()).unwrap();
let trkseg = &gpx.trk[0].trkseg[0];
let global = Statistics::compute(trkseg).global;
let values: Vec<f64> = trkseg
.iter()
.filter_map(|trkpt| match measure {
0 => trkpt.hr.map(f64::from),
1 => trkpt.cad.map(f64::from),
2 => trkpt.atemp.map(f64::from),
_ => trkpt.power.map(f64::from),
})
.collect();
let average = [global.hr, global.cad, global.atemp, global.power][measure];
assert!(!values.is_empty(), "{path}");
assert_eq!(average.count as usize, values.len(), "{path}");
let expected = values.iter().sum::<f64>() / values.len() as f64;
assert!((average.avg().unwrap() - expected).abs() < 1e-9, "{path}");
}
}
} }
@@ -22,10 +22,9 @@ pub fn time_diff(a: Option<i64>, b: Option<i64>) -> Option<i64> {
Some(a? - b?) Some(a? - b?)
} }
/// Computes the speed in km/h for a given distance in kilometers and a time in milliseconds. /// Computes the speed for a given distance in kilometers and a time in milliseconds
/// Unknown if the time is not a positive duration. pub fn speed(distance: f64, time: i64) -> f64 {
pub fn speed(distance: f64, time: i64) -> Option<f64> { distance / (time as f64 / 3_600_000.0)
(time > 0).then(|| distance / (time as f64 / 3_600_000.0))
} }
pub fn slope(ele: f64, distance: f64) -> f64 { pub fn slope(ele: f64, distance: f64) -> f64 {
@@ -126,7 +125,7 @@ mod tests {
assert_eq!(time_diff(None, Some(1)), None); assert_eq!(time_diff(None, Some(1)), None);
assert_eq!(time_diff(Some(1), None), None); assert_eq!(time_diff(Some(1), None), None);
// 1 km in one hour // 1 km in one hour
assert!((speed(1.0, 3_600_000).unwrap() - 1.0).abs() < 1e-12); assert!((speed(1.0, 3_600_000) - 1.0).abs() < 1e-12);
} }
#[test] #[test]
@@ -155,13 +154,9 @@ mod tests {
#[test] #[test]
fn test_speed() { fn test_speed() {
// 1 km in 1 h // 1 km in 1 h
assert!((speed(1.0, 3_600_000).unwrap() - 1.0).abs() < 1e-12); assert!((speed(1.0, 3_600_000) - 1.0).abs() < 1e-12);
// 10 km in 30 min // 10 km in 30 min
assert!((speed(10.0, 1_800_000).unwrap() - 20.0).abs() < 1e-12); assert!((speed(10.0, 1_800_000) - 20.0).abs() < 1e-12);
// no duration, no speed
assert_eq!(speed(1.0, 0), None);
assert_eq!(speed(0.0, 0), None);
assert_eq!(speed(1.0, -1000), None);
} }
#[test] #[test]
@@ -36,11 +36,4 @@ pub enum Action<'a> {
file_ids: Vec<FileId>, file_ids: Vec<FileId>,
index: usize, index: usize,
}, },
/// Names a file in all the states of the history, as if it had always been called so (see
/// [`crate::History::rename`]). Not undoable: for a file that is given a name from the outside,
/// like the name of the file it is written to.
Rename {
file_id: FileId,
name: String,
},
} }
@@ -12,6 +12,8 @@ pub trait Apply {
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub enum CommandError { pub enum CommandError {
/// The command is not implemented yet.
NotImplemented(&'static str),
/// The command would not change anything. /// The command would not change anything.
NothingToDo, NothingToDo,
/// The input data could not be parsed. /// The input data could not be parsed.
@@ -21,6 +23,7 @@ pub enum CommandError {
impl fmt::Display for CommandError { impl fmt::Display for CommandError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {
Self::NotImplemented(name) => write!(f, "{name} is not implemented yet"),
Self::NothingToDo => write!(f, "nothing to do"), Self::NothingToDo => write!(f, "nothing to do"),
Self::InvalidData(err) => write!(f, "invalid data: {err}"), Self::InvalidData(err) => write!(f, "invalid data: {err}"),
} }
@@ -1,20 +1,9 @@
mod apply; use crate::{Apply, CommandError, State};
mod edit; use crate::{
mod file; Clean, Crop, Delete, DeleteAll, DeleteWaypoint, Duplicate, EditWaypoint, Elevation, Extract,
#[cfg(test)] Load, LoadFiles, Merge, Metadata, Move, MoveWaypoint, New, NewTrack, NewTrackSegment,
pub(crate) mod fixture; NewWaypoint, Paste, Reverse, SpliceTrackpoints, Split, Style, Time,
mod pattern; };
#[cfg(test)]
mod routes_tests;
mod tools;
pub use apply::*;
pub use edit::*;
pub use file::*;
pub use pattern::*;
pub use tools::*;
use crate::State;
/// A user action that edits the files. Each variant wraps the command's own struct, whose /// A user action that edits the files. Each variant wraps the command's own struct, whose
/// effect is implemented in its own file (see `Apply`). /// effect is implemented in its own file (see `Apply`).
@@ -26,35 +15,28 @@ pub enum Command<'a> {
New(New<'a>), New(New<'a>),
Load(Load<'a>), Load(Load<'a>),
LoadFiles(LoadFiles<'a>), LoadFiles(LoadFiles<'a>),
SyncFiles(SyncFiles<'a>),
Duplicate(Duplicate), Duplicate(Duplicate),
Delete(Delete), Delete(Delete),
Paste(Paste), Paste(Paste),
Move(Move), Move(Move),
DeleteAll(DeleteAll), DeleteAll(DeleteAll),
DeleteWaypoint(DeleteWaypoint), DeleteWaypoint(DeleteWaypoint),
Convert(Convert),
Metadata(Metadata<'a>), Metadata(Metadata<'a>),
Style(Style<'a>), Style(Style<'a>),
NewRoute(NewRoute),
NewTrack(NewTrack), NewTrack(NewTrack),
NewTrackSegment(NewTrackSegment), NewTrackSegment(NewTrackSegment),
Reverse(Reverse), Reverse(Reverse),
RoundTrip(RoundTrip), SpliceTrackpoints(SpliceTrackpoints<'a>),
Reroute(Reroute<'a>),
NewWaypoint(NewWaypoint<'a>), NewWaypoint(NewWaypoint<'a>),
EditWaypoint(EditWaypoint<'a>), EditWaypoint(EditWaypoint<'a>),
MoveWaypoint(MoveWaypoint), MoveWaypoint(MoveWaypoint),
Crop(Crop), Crop(Crop),
Reduce(Reduce),
Split(Split), Split(Split),
Time(Time), Time(Time),
Merge(Merge), Merge(Merge),
Extract(Extract), Extract(Extract),
InsertAnchor(InsertAnchor),
Elevation(Elevation<'a>), Elevation(Elevation<'a>),
Clean(Clean), Clean(Clean),
ChangeLoopStart(ChangeLoopStart),
} }
impl Apply for Command<'_> { impl Apply for Command<'_> {
@@ -63,35 +45,28 @@ impl Apply for Command<'_> {
Command::New(c) => c.apply(state), Command::New(c) => c.apply(state),
Command::Load(c) => c.apply(state), Command::Load(c) => c.apply(state),
Command::LoadFiles(c) => c.apply(state), Command::LoadFiles(c) => c.apply(state),
Command::SyncFiles(c) => c.apply(state),
Command::Duplicate(c) => c.apply(state), Command::Duplicate(c) => c.apply(state),
Command::Delete(c) => c.apply(state), Command::Delete(c) => c.apply(state),
Command::Paste(c) => c.apply(state), Command::Paste(c) => c.apply(state),
Command::Move(c) => c.apply(state), Command::Move(c) => c.apply(state),
Command::DeleteAll(c) => c.apply(state), Command::DeleteAll(c) => c.apply(state),
Command::DeleteWaypoint(c) => c.apply(state), Command::DeleteWaypoint(c) => c.apply(state),
Command::Convert(c) => c.apply(state),
Command::Metadata(c) => c.apply(state), Command::Metadata(c) => c.apply(state),
Command::Style(c) => c.apply(state), Command::Style(c) => c.apply(state),
Command::NewRoute(c) => c.apply(state),
Command::NewTrack(c) => c.apply(state), Command::NewTrack(c) => c.apply(state),
Command::NewTrackSegment(c) => c.apply(state), Command::NewTrackSegment(c) => c.apply(state),
Command::Reverse(c) => c.apply(state), Command::Reverse(c) => c.apply(state),
Command::RoundTrip(c) => c.apply(state), Command::SpliceTrackpoints(c) => c.apply(state),
Command::Reroute(c) => c.apply(state),
Command::NewWaypoint(c) => c.apply(state), Command::NewWaypoint(c) => c.apply(state),
Command::EditWaypoint(c) => c.apply(state), Command::EditWaypoint(c) => c.apply(state),
Command::MoveWaypoint(c) => c.apply(state), Command::MoveWaypoint(c) => c.apply(state),
Command::Crop(c) => c.apply(state), Command::Crop(c) => c.apply(state),
Command::Reduce(c) => c.apply(state),
Command::Split(c) => c.apply(state), Command::Split(c) => c.apply(state),
Command::Time(c) => c.apply(state), Command::Time(c) => c.apply(state),
Command::Merge(c) => c.apply(state), Command::Merge(c) => c.apply(state),
Command::Extract(c) => c.apply(state), Command::Extract(c) => c.apply(state),
Command::InsertAnchor(c) => c.apply(state),
Command::Elevation(c) => c.apply(state), Command::Elevation(c) => c.apply(state),
Command::Clean(c) => c.apply(state), Command::Clean(c) => c.apply(state),
Command::ChangeLoopStart(c) => c.apply(state),
} }
} }
} }
@@ -1,6 +1,4 @@
use crate::{ use crate::{Apply, CommandError, Edit, Editor, File, State, Track, update_selected};
Apply, CommandError, Edit, Editor, File, Route, State, Track, TrackInfo, update_selected,
};
#[derive(Debug)] #[derive(Debug)]
pub struct Metadata<'a> { pub struct Metadata<'a> {
@@ -15,33 +13,21 @@ impl Apply for Metadata<'_> {
} }
} }
impl Metadata<'_> {
fn set(&self, info: &mut TrackInfo) -> Edit {
info.name = Some(self.name.to_owned());
info.desc = Some(self.desc.to_owned());
Edit::Changed
}
}
impl Editor for Metadata<'_> { impl Editor for Metadata<'_> {
fn file(&mut self, file: &mut File) -> Edit { fn file(&mut self, file: &mut File) -> Edit {
file.info.name = self.name.to_owned(); file.info.name = self.name.to_owned();
file.info.desc = Some(self.desc.to_owned()); file.info.desc = Some(self.desc.to_owned());
// a single route or track is named like the file // a single track is named like the file
match (file.rte.as_mut_slice(), file.trk.as_mut_slice()) { if let [track] = file.trk.as_mut_slice() {
([route], []) => route.info.name = Some(self.name.to_owned()), track.info.name = Some(self.name.to_owned());
([], [track]) => track.info.name = Some(self.name.to_owned()),
_ => {}
} }
Edit::Changed Edit::Changed
} }
fn route(&mut self, route: &mut Route) -> Edit {
self.set(&mut route.info)
}
fn track(&mut self, track: &mut Track) -> Edit { fn track(&mut self, track: &mut Track) -> Edit {
self.set(&mut track.info) track.info.name = Some(self.name.to_owned());
track.info.desc = Some(self.desc.to_owned());
Edit::Changed
} }
} }
@@ -56,20 +42,8 @@ mod tests {
#[test] #[test]
fn test_metadata_applies_to_selected_file() { fn test_metadata_applies_to_selected_file() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
New { New { name: "first" }.apply(&mut fx.state()).unwrap();
name: "first", New { name: "second" }.apply(&mut fx.state()).unwrap(); // now selected
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
New {
name: "second",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap(); // now selected
let selected = *fx.selected_files().iter().next().unwrap(); let selected = *fx.selected_files().iter().next().unwrap();
Metadata { Metadata {
@@ -121,13 +95,7 @@ mod tests {
/// A new file with `nb_tracks` tracks (without name), selected. /// A new file with `nb_tracks` tracks (without name), selected.
fn file_with_tracks(fx: &mut Fixture, nb_tracks: usize) { fn file_with_tracks(fx: &mut Fixture, nb_tracks: usize) {
New { New { name: "file" }.apply(&mut fx.state()).unwrap();
name: "file",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
for _ in 0..nb_tracks { for _ in 0..nb_tracks {
NewTrack.apply(&mut fx.state()).unwrap(); NewTrack.apply(&mut fx.state()).unwrap();
} }
@@ -1,13 +1,9 @@
mod convert;
mod metadata; mod metadata;
mod new_route;
mod new_track; mod new_track;
mod new_track_segment; mod new_track_segment;
mod style; mod style;
pub use convert::*;
pub use metadata::*; pub use metadata::*;
pub use new_route::*;
pub use new_track::*; pub use new_track::*;
pub use new_track_segment::*; pub use new_track_segment::*;
pub use style::*; pub use style::*;
@@ -1,4 +1,4 @@
use crate::{Apply, CommandError, Edit, Editor, File, State, Track, TrackInfo, update_selected}; use crate::{Apply, CommandError, Edit, Editor, File, State, Track, update_selected};
#[derive(Debug)] #[derive(Debug)]
pub struct NewTrack; pub struct NewTrack;
@@ -12,41 +12,20 @@ impl Apply for NewTrack {
impl Editor for NewTrack { impl Editor for NewTrack {
fn file(&mut self, file: &mut File) -> Edit { fn file(&mut self, file: &mut File) -> Edit {
file.trk.push(Track { let mut track = Track::default();
info: common_style(file), track.info.color = common(file, |t| &t.info.color);
..Default::default() track.info.opacity = common(file, |t| &t.info.opacity);
}); track.info.width = common(file, |t| &t.info.width);
file.trk.push(track);
Edit::Changed Edit::Changed
} }
} }
/// The style that all the routes and tracks of the file agree on: each attribute is set if they /// Returns the value of a style attribute if all existing tracks agree on it.
/// all have the same value for it. fn common<T: Clone + PartialEq>(file: &File, get: impl Fn(&Track) -> &Option<T>) -> Option<T> {
pub(super) fn common_style(file: &File) -> TrackInfo { let mut tracks = file.trk.iter();
let infos: Vec<&TrackInfo> = file let first = get(tracks.next()?);
.rte tracks.all(|t| get(t) == first).then(|| first.clone())?
.iter()
.map(|rte| &rte.info)
.chain(file.trk.iter().map(|trk| &trk.info))
.collect();
TrackInfo {
color: common(&infos, |info| &info.color),
opacity: common(&infos, |info| &info.opacity),
width: common(&infos, |info| &info.width),
..Default::default()
}
}
/// Returns the value of a style attribute if all the infos agree on it.
fn common<T: Clone + PartialEq>(
infos: &[&TrackInfo],
get: impl Fn(&TrackInfo) -> &Option<T>,
) -> Option<T> {
let mut infos = infos.iter();
let first = get(infos.next()?);
infos
.all(|info| get(info) == first)
.then(|| first.clone())?
} }
#[cfg(test)] #[cfg(test)]
@@ -58,13 +37,7 @@ mod tests {
#[test] #[test]
fn test_new_track() { fn test_new_track() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
New { New { name: "file" }.apply(&mut fx.state()).unwrap();
name: "file",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
NewTrack.apply(&mut fx.state()).unwrap(); NewTrack.apply(&mut fx.state()).unwrap();
NewTrack.apply(&mut fx.state()).unwrap(); NewTrack.apply(&mut fx.state()).unwrap();
let file = fx.files.values().next().unwrap(); let file = fx.files.values().next().unwrap();
@@ -75,13 +48,7 @@ mod tests {
#[test] #[test]
fn test_new_track_inherits_agreeing_style_only() { fn test_new_track_inherits_agreeing_style_only() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
New { New { name: "file" }.apply(&mut fx.state()).unwrap();
name: "file",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
NewTrack.apply(&mut fx.state()).unwrap(); NewTrack.apply(&mut fx.state()).unwrap();
NewTrack.apply(&mut fx.state()).unwrap(); NewTrack.apply(&mut fx.state()).unwrap();
let file = std::rc::Rc::make_mut(fx.files.values_mut().next().unwrap()); let file = std::rc::Rc::make_mut(fx.files.values_mut().next().unwrap());
@@ -26,13 +26,7 @@ mod tests {
#[test] #[test]
fn test_new_track_segment_on_each_track_of_selected_file() { fn test_new_track_segment_on_each_track_of_selected_file() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
New { New { name: "file" }.apply(&mut fx.state()).unwrap();
name: "file",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
NewTrack.apply(&mut fx.state()).unwrap(); NewTrack.apply(&mut fx.state()).unwrap();
NewTrack.apply(&mut fx.state()).unwrap(); NewTrack.apply(&mut fx.state()).unwrap();
NewTrackSegment.apply(&mut fx.state()).unwrap(); NewTrackSegment.apply(&mut fx.state()).unwrap();
@@ -1,4 +1,4 @@
use crate::{Apply, CommandError, Edit, Editor, Route, State, Track, TrackInfo, update_selected}; use crate::{Apply, CommandError, Edit, Editor, State, Track, update_selected};
#[derive(Debug)] #[derive(Debug)]
pub struct Style<'a> { pub struct Style<'a> {
@@ -14,31 +14,21 @@ impl Apply for Style<'_> {
} }
} }
impl Style<'_> { impl Editor for Style<'_> {
fn set(&self, info: &mut TrackInfo) -> Edit { fn track(&mut self, track: &mut Track) -> Edit {
if let Some(color) = self.color { if let Some(color) = self.color {
info.color = Some(color.to_owned()); track.info.color = Some(color.to_owned());
} }
if self.opacity.is_some() { if self.opacity.is_some() {
info.opacity = self.opacity; track.info.opacity = self.opacity;
} }
if self.width.is_some() { if self.width.is_some() {
info.width = self.width; track.info.width = self.width;
} }
Edit::Changed Edit::Changed
} }
} }
impl Editor for Style<'_> {
fn route(&mut self, route: &mut Route) -> Edit {
self.set(&mut route.info)
}
fn track(&mut self, track: &mut Track) -> Edit {
self.set(&mut track.info)
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::collections::HashSet; use std::collections::HashSet;
@@ -1,9 +1,11 @@
use std::rc::Rc; use std::rc::Rc;
use crate::{Apply, CommandError, FileId, Files, Selection, State, Waypoint}; use crate::{
Apply, CommandError, FileId, Selection, StackEntry, State, Waypoint, edit_waypoint_chunks,
};
/// Deletes the selected elements. With `whole_files`, the files holding the selected elements /// Deletes the selected elements. With `whole_files`, the files holding the selected elements
/// are deleted instead, even if only a route, a track or a waypoint is selected. /// are deleted instead, even if only a track or a waypoint is selected.
#[derive(Debug)] #[derive(Debug)]
pub struct Delete { pub struct Delete {
pub whole_files: bool, pub whole_files: bool,
@@ -23,21 +25,6 @@ impl Apply for Delete {
state.order.0.retain(|id| !file_ids.contains(id)); state.order.0.retain(|id| !file_ids.contains(id));
Selection::Empty Selection::Empty
} }
Selection::Route { file_id, rte_ids } => {
let file = state
.files
.get_mut(file_id)
.ok_or(CommandError::NothingToDo)?;
let file = Rc::make_mut(file);
let len = file.rte.len();
file.rte.retain(|rte| !rte_ids.contains(&rte.id));
if file.rte.len() == len {
return Err(CommandError::NothingToDo);
}
Selection::File {
file_ids: [*file_id].into(),
}
}
Selection::Track { file_id, trk_ids } => { Selection::Track { file_id, trk_ids } => {
let file = state let file = state
.files .files
@@ -90,13 +77,13 @@ impl Apply for Delete {
} }
pub(crate) fn delete_waypoints( pub(crate) fn delete_waypoints(
files: &mut Files, files: &mut StackEntry,
file_id: FileId, file_id: FileId,
filter: impl Fn(&Waypoint) -> bool, filter: impl Fn(&Waypoint) -> bool,
) -> Result<Selection, CommandError> { ) -> Result<Selection, CommandError> {
let file = files.get(&file_id).ok_or(CommandError::NothingToDo)?; let file = files.get(&file_id).ok_or(CommandError::NothingToDo)?;
let mut file = (**file).clone(); let mut file = (**file).clone();
let changed = file.wpt.edit(&filter, |wpts| { let changed = edit_waypoint_chunks(&mut file, &filter, |wpts| {
wpts.retain(|wpt| !filter(wpt)); wpts.retain(|wpt| !filter(wpt));
true true
}); });
@@ -143,13 +130,7 @@ mod tests {
#[test] #[test]
fn test_delete_selected_files() { fn test_delete_selected_files() {
let (mut fx, id) = loaded(); let (mut fx, id) = loaded();
crate::New { crate::New { name: "keep" }.apply(&mut fx.state()).unwrap();
name: "keep",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
let keep = fx.order.0[1]; let keep = fx.order.0[1];
fx.selection = Selection::File { fx.selection = Selection::File {
file_ids: HashSet::from([id]), file_ids: HashSet::from([id]),
@@ -205,10 +186,10 @@ mod tests {
let wpts: Vec<_> = (0..n).map(|_| Waypoint::default()).collect(); let wpts: Vec<_> = (0..n).map(|_| Waypoint::default()).collect();
let ids = wpts.iter().map(|w| w.id).collect(); let ids = wpts.iter().map(|w| w.id).collect();
let mut file = (*fx.files[&id]).clone(); let mut file = (*fx.files[&id]).clone();
file.wpt = crate::Waypoints::new([crate::WaypointChunk { file.wpt = vec![Rc::new(crate::WaypointChunk {
wpt: wpts, wpt: wpts,
..Default::default() ..Default::default()
}]); })];
fx.files.insert(id, Rc::new(file)); fx.files.insert(id, Rc::new(file));
ids ids
} }
@@ -221,12 +202,16 @@ mod tests {
file_id: id, file_id: id,
wpt_ids: HashSet::from([ids[1]]), wpt_ids: HashSet::from([ids[1]]),
}; };
let rev = fx.files[&id].wpt.rev_id; let rev = fx.files[&id].wpt_rev_id;
Delete { whole_files: false } Delete { whole_files: false }
.apply(&mut fx.state()) .apply(&mut fx.state())
.unwrap(); .unwrap();
assert_ne!(fx.files[&id].wpt.rev_id, rev); assert_ne!(fx.files[&id].wpt_rev_id, rev);
let left: Vec<_> = fx.files[&id].wpt.iter().map(|w| w.id).collect(); let left: Vec<_> = fx.files[&id]
.wpt
.iter()
.flat_map(|c| c.wpt.iter().map(|w| w.id))
.collect();
assert_eq!(left, vec![ids[0], ids[2]]); assert_eq!(left, vec![ids[0], ids[2]]);
assert_eq!(fx.selected_files(), HashSet::from([id])); assert_eq!(fx.selected_files(), HashSet::from([id]));
} }
@@ -278,13 +263,7 @@ mod tests {
}, },
] { ] {
let (mut fx, id) = loaded(); let (mut fx, id) = loaded();
crate::New { crate::New { name: "keep" }.apply(&mut fx.state()).unwrap();
name: "keep",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
let keep = fx.order.0[1]; let keep = fx.order.0[1];
fx.selection = selection(id, &fx); fx.selection = selection(id, &fx);
Delete { whole_files: true }.apply(&mut fx.state()).unwrap(); Delete { whole_files: true }.apply(&mut fx.state()).unwrap();
@@ -28,20 +28,8 @@ mod tests {
DeleteAll.apply(&mut fx.state()), DeleteAll.apply(&mut fx.state()),
Err(CommandError::NothingToDo) Err(CommandError::NothingToDo)
); );
crate::New { crate::New { name: "a" }.apply(&mut fx.state()).unwrap();
name: "a", crate::New { name: "b" }.apply(&mut fx.state()).unwrap();
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
crate::New {
name: "b",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
assert!(DeleteAll.apply(&mut fx.state()).is_ok()); assert!(DeleteAll.apply(&mut fx.state()).is_ok());
assert!(fx.files.is_empty()); assert!(fx.files.is_empty());
assert!(fx.order.0.is_empty()); assert!(fx.order.0.is_empty());
@@ -37,7 +37,7 @@ mod tests {
fn test_deletes_one_waypoint_without_touching_the_selection() { fn test_deletes_one_waypoint_without_touching_the_selection() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
let mut file = File::default(); let mut file = File::default();
file.wpt.push(WaypointChunk { file.wpt.push(Rc::new(WaypointChunk {
wpt: (0..3) wpt: (0..3)
.map(|i| Waypoint { .map(|i| Waypoint {
name: Some(format!("w{i}")), name: Some(format!("w{i}")),
@@ -45,7 +45,7 @@ mod tests {
}) })
.collect(), .collect(),
..Default::default() ..Default::default()
}); }));
let id = file.id; let id = file.id;
let ids: Vec<_> = waypoint_ids(&file).collect(); let ids: Vec<_> = waypoint_ids(&file).collect();
fx.files.insert(id, Rc::new(file)); fx.files.insert(id, Rc::new(file));
@@ -64,6 +64,7 @@ mod tests {
let names: Vec<_> = fx.files[&id] let names: Vec<_> = fx.files[&id]
.wpt .wpt
.iter() .iter()
.flat_map(|chunk| &chunk.wpt)
.map(|wpt| wpt.name.clone().unwrap()) .map(|wpt| wpt.name.clone().unwrap())
.collect(); .collect();
assert_eq!(names, ["w0", "w2"]); assert_eq!(names, ["w0", "w2"]);
@@ -79,10 +80,10 @@ mod tests {
fn test_deleting_the_selected_waypoint_selects_its_file() { fn test_deleting_the_selected_waypoint_selects_its_file() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
let mut file = File::default(); let mut file = File::default();
file.wpt.push(WaypointChunk { file.wpt.push(Rc::new(WaypointChunk {
wpt: vec![Waypoint::default(), Waypoint::default()], wpt: vec![Waypoint::default(), Waypoint::default()],
..Default::default() ..Default::default()
}); }));
let id = file.id; let id = file.id;
let ids: Vec<_> = waypoint_ids(&file).collect(); let ids: Vec<_> = waypoint_ids(&file).collect();
fx.files.insert(id, Rc::new(file)); fx.files.insert(id, Rc::new(file));
@@ -1,8 +1,8 @@
use std::{collections::HashSet, rc::Rc}; use std::{collections::HashSet, rc::Rc};
use crate::{ use crate::{
Apply, CommandError, FileId, Files, Selection, State, Waypoint, copy_file, copy_route, Apply, CommandError, FileId, Selection, StackEntry, State, Waypoint, copy_file, copy_segment,
copy_segment, copy_track, copy_waypoint, copy_track, copy_waypoint, insert_waypoints,
}; };
#[derive(Debug)] #[derive(Debug)]
@@ -35,30 +35,6 @@ impl Apply for Duplicate {
state.order.0.splice(at..at, order); state.order.0.splice(at..at, order);
Selection::File { file_ids: copies } Selection::File { file_ids: copies }
} }
Selection::Route { file_id, rte_ids } => {
let file = state
.files
.get_mut(file_id)
.ok_or(CommandError::NothingToDo)?;
let file = Rc::make_mut(file);
let mut copies = HashSet::new();
append_copies(
&mut file.rte,
|rte| rte_ids.contains(&rte.id),
|rte| {
let copy = copy_route(rte);
copies.insert(copy.id);
copy
},
);
if copies.is_empty() {
return Err(CommandError::NothingToDo);
}
Selection::Route {
file_id: *file_id,
rte_ids: copies,
}
}
Selection::Track { file_id, trk_ids } => { Selection::Track { file_id, trk_ids } => {
let file = state let file = state
.files .files
@@ -131,19 +107,24 @@ impl Apply for Duplicate {
} }
fn duplicate_waypoints( fn duplicate_waypoints(
files: &mut Files, files: &mut StackEntry,
file_id: FileId, file_id: FileId,
filter: impl Fn(&Waypoint) -> bool, filter: impl Fn(&Waypoint) -> bool,
) -> Result<Selection, CommandError> { ) -> Result<Selection, CommandError> {
let file = files.get(&file_id).ok_or(CommandError::NothingToDo)?; let file = files.get(&file_id).ok_or(CommandError::NothingToDo)?;
let selected: Vec<&Waypoint> = file.wpt.iter().filter(|wpt| filter(wpt)).collect(); let selected: Vec<&Waypoint> = file
.wpt
.iter()
.flat_map(|chunk| &chunk.wpt)
.filter(|wpt| filter(wpt))
.collect();
let last = selected.last().ok_or(CommandError::NothingToDo)?.id; let last = selected.last().ok_or(CommandError::NothingToDo)?.id;
let copies: Vec<Waypoint> = selected.into_iter().map(copy_waypoint).collect(); let copies: Vec<Waypoint> = selected.into_iter().map(copy_waypoint).collect();
let copy_ids = copies.iter().map(|wpt| wpt.id).collect(); let copy_ids = copies.iter().map(|wpt| wpt.id).collect();
// The copies go right after the last selected waypoint. // The copies go right after the last selected waypoint.
let mut file = (**file).clone(); let mut file = (**file).clone();
file.wpt.insert_after(Some(last), copies); insert_waypoints(&mut file, Some(last), copies);
files.insert(file_id, Rc::new(file)); files.insert(file_id, Rc::new(file));
Ok(Selection::Waypoint { Ok(Selection::Waypoint {
file_id, file_id,
@@ -214,13 +195,7 @@ mod tests {
fn test_duplicate_files_go_after_last_selected() { fn test_duplicate_files_go_after_last_selected() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
for name in ["a", "b", "c"] { for name in ["a", "b", "c"] {
crate::New { crate::New { name }.apply(&mut fx.state()).unwrap();
name,
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
} }
let [a, b, c] = [fx.order.0[0], fx.order.0[1], fx.order.0[2]]; let [a, b, c] = [fx.order.0[0], fx.order.0[1], fx.order.0[2]];
fx.selection = Selection::File { fx.selection = Selection::File {
@@ -263,44 +238,57 @@ mod tests {
let wpts: Vec<_> = (0..3).map(|_| Waypoint::default()).collect(); let wpts: Vec<_> = (0..3).map(|_| Waypoint::default()).collect();
let ids: Vec<_> = wpts.iter().map(|w| w.id).collect(); let ids: Vec<_> = wpts.iter().map(|w| w.id).collect();
let mut file = (*fx.files[&id]).clone(); let mut file = (*fx.files[&id]).clone();
file.wpt = crate::Waypoints::new([crate::WaypointChunk { file.wpt = vec![Rc::new(crate::WaypointChunk {
wpt: wpts, wpt: wpts,
..Default::default() ..Default::default()
}]); })];
fx.files.insert(id, Rc::new(file)); fx.files.insert(id, Rc::new(file));
let original_chunk = fx.files[&id].wpt.chunks()[0].clone(); let original_chunk = fx.files[&id].wpt[0].clone();
fx.selection = Selection::Waypoint { fx.selection = Selection::Waypoint {
file_id: id, file_id: id,
wpt_ids: HashSet::from([ids[0]]), wpt_ids: HashSet::from([ids[0]]),
}; };
let rev = fx.files[&id].wpt.rev_id; let rev = fx.files[&id].wpt_rev_id;
Duplicate.apply(&mut fx.state()).unwrap(); Duplicate.apply(&mut fx.state()).unwrap();
assert_ne!(fx.files[&id].wpt.rev_id, rev); assert_ne!(fx.files[&id].wpt_rev_id, rev);
let all: Vec<_> = fx.files[&id].wpt.iter().map(|w| w.id).collect(); let all: Vec<_> = fx.files[&id]
.wpt
.iter()
.flat_map(|c| c.wpt.iter().map(|w| w.id))
.collect();
assert_eq!(all.len(), 4); assert_eq!(all.len(), 4);
assert!( assert!(
matches!(&fx.selection, Selection::Waypoint { wpt_ids, .. } if wpt_ids == &HashSet::from([all[1]])) matches!(&fx.selection, Selection::Waypoint { wpt_ids, .. } if wpt_ids == &HashSet::from([all[1]]))
); );
// the copy comes right after the selected waypoint, in a new chunk // the chunk is cut after the selected waypoint: [w0] [copy] [w1 w2]
assert_eq!(all[..], [ids[0], all[1], ids[1], ids[2]]); assert_eq!(all[..], [ids[0], all[1], ids[1], ids[2]]);
assert_eq!(fx.files[&id].wpt.chunks().len(), 1); assert_eq!(fx.files[&id].wpt.len(), 3);
assert_ne!(fx.files[&id].wpt.chunks()[0].id, original_chunk.id); assert_ne!(fx.files[&id].wpt[0].id, original_chunk.id);
// selecting the last waypoint: the copy goes at the end // selecting the last waypoint of a chunk does not cut it
let last = fx.files[&id].wpt.iter().last().unwrap().id; let last = fx.files[&id].wpt.last().unwrap().wpt.last().unwrap().id;
let chunks = fx.files[&id].wpt.clone();
fx.selection = Selection::Waypoint { fx.selection = Selection::Waypoint {
file_id: id, file_id: id,
wpt_ids: HashSet::from([last]), wpt_ids: HashSet::from([last]),
}; };
Duplicate.apply(&mut fx.state()).unwrap(); Duplicate.apply(&mut fx.state()).unwrap();
let all: Vec<_> = fx.files[&id].wpt.iter().map(|w| w.id).collect(); let file = &fx.files[&id];
assert_eq!(all.len(), 5); assert_eq!(file.wpt.len(), 4);
assert_eq!(all[..4], [ids[0], all[1], ids[1], ids[2]]); assert!(
file.wpt[..3]
.iter()
.zip(&chunks)
.all(|(a, b)| Rc::ptr_eq(a, b))
);
fx.selection = Selection::Waypoints { file_id: id }; fx.selection = Selection::Waypoints { file_id: id };
Duplicate.apply(&mut fx.state()).unwrap(); Duplicate.apply(&mut fx.state()).unwrap();
assert_eq!(fx.files[&id].wpt.len(), 10); assert_eq!(
fx.files[&id].wpt.iter().map(|c| c.wpt.len()).sum::<usize>(),
10
);
} }
#[test] #[test]
@@ -9,7 +9,7 @@ pub struct Load<'a> {
} }
impl Load<'_> { impl Load<'_> {
pub(crate) fn parse(self, categories: &mut TrackpointCategories) -> Result<File, CommandError> { fn parse(self, categories: &mut TrackpointCategories) -> Result<File, CommandError> {
let mut file = parse(self.data, categories) let mut file = parse(self.data, categories)
.map_err(|err| CommandError::InvalidData(err.to_string()))?; .map_err(|err| CommandError::InvalidData(err.to_string()))?;
if file.info.name.trim().is_empty() { if file.info.name.trim().is_empty() {
@@ -82,13 +82,7 @@ mod tests {
#[test] #[test]
fn test_load_invalid_file_changes_nothing() { fn test_load_invalid_file_changes_nothing() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
crate::New { crate::New { name: "keep" }.apply(&mut fx.state()).unwrap();
name: "keep",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
let selected = fx.selected_files(); let selected = fx.selected_files();
let result = Load { let result = Load {
@@ -138,13 +132,9 @@ mod tests {
#[test] #[test]
fn test_load_several_files() { fn test_load_several_files() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
crate::New { crate::New { name: "before" }
name: "before", .apply(&mut fx.state())
trackpoint: None, .unwrap();
route: false,
}
.apply(&mut fx.state())
.unwrap();
let before = fx.order.0[0]; let before = fx.order.0[0];
let (a, b, c) = (gpx("a"), gpx("b"), gpx("c")); let (a, b, c) = (gpx("a"), gpx("b"), gpx("c"));
@@ -188,13 +178,7 @@ mod tests {
#[test] #[test]
fn test_load_several_invalid_files_changes_nothing() { fn test_load_several_invalid_files_changes_nothing() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
crate::New { crate::New { name: "keep" }.apply(&mut fx.state()).unwrap();
name: "keep",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
let selected = fx.selected_files(); let selected = fx.selected_files();
let result = LoadFiles { let result = LoadFiles {
@@ -6,7 +6,6 @@ mod load;
mod move_elements; mod move_elements;
mod new; mod new;
mod paste; mod paste;
mod sync;
mod transfer; mod transfer;
pub use delete::*; pub use delete::*;
@@ -17,5 +16,4 @@ pub use load::*;
pub use move_elements::*; pub use move_elements::*;
pub use new::*; pub use new::*;
pub use paste::*; pub use paste::*;
pub use sync::*;
pub use transfer::*; pub use transfer::*;
@@ -9,8 +9,6 @@ use crate::{
pub enum MoveTarget { pub enum MoveTarget {
/// The list of files. /// The list of files.
Files { index: usize }, Files { index: usize },
/// The routes of a file.
Routes { file_id: FileId, index: usize },
/// The tracks of a file. /// The tracks of a file.
Tracks { file_id: FileId, index: usize }, Tracks { file_id: FileId, index: usize },
/// The segments of a track. /// The segments of a track.
@@ -28,10 +26,9 @@ pub enum MoveTarget {
/// ///
/// What can go where: /// What can go where:
/// - files: among the files; /// - files: among the files;
/// - routes and tracks: among the files (each one becomes a file), or among the routes or the /// - tracks: among the files (each track becomes a file), or among the tracks of a file;
/// tracks of a file, where they keep their kind (see [`Destination`]); /// - segments: among the files (each segment becomes a file), among the tracks of a file (each
/// - segments: among the files (each segment becomes a file), among the routes or the tracks of a /// segment becomes a track), or among the segments of a track;
/// file (each segment becomes a route or a track), or among the segments of a track;
/// - waypoints, or all the waypoints of a file (the waypoints node): among the waypoints of a /// - waypoints, or all the waypoints of a file (the waypoints node): among the waypoints of a
/// file. /// file.
#[derive(Debug)] #[derive(Debug)]
@@ -44,9 +41,6 @@ impl From<MoveTarget> for Destination {
fn from(target: MoveTarget) -> Self { fn from(target: MoveTarget) -> Self {
match target { match target {
MoveTarget::Files { index } => Destination::Files(Place::Index(index)), MoveTarget::Files { index } => Destination::Files(Place::Index(index)),
MoveTarget::Routes { file_id, index } => {
Destination::Routes(file_id, Place::Index(index))
}
MoveTarget::Tracks { file_id, index } => { MoveTarget::Tracks { file_id, index } => {
Destination::Tracks(file_id, Place::Index(index)) Destination::Tracks(file_id, Place::Index(index))
} }
@@ -77,7 +71,7 @@ mod tests {
use crate::{ use crate::{
File, Track, TrackInfo, TrackSegment, TrackSegmentId, Waypoint, WaypointChunk, WaypointId, File, Track, TrackInfo, TrackSegment, TrackSegmentId, Waypoint, WaypointChunk, WaypointId,
Waypoints, engine::command::fixture::Fixture, new_file, waypoint_ids, engine::command::fixture::Fixture, new_file, waypoint_ids,
}; };
use super::*; use super::*;
@@ -99,10 +93,10 @@ mod tests {
.collect(), .collect(),
); );
if waypoints > 0 { if waypoints > 0 {
file.wpt = Waypoints::new([WaypointChunk { file.wpt = vec![Rc::new(WaypointChunk {
wpt: (0..waypoints).map(|_| Waypoint::default()).collect(), wpt: (0..waypoints).map(|_| Waypoint::default()).collect(),
..Default::default() ..Default::default()
}]); })];
} }
file file
} }
@@ -0,0 +1,36 @@
use crate::{Apply, CommandError, File, State, produce};
#[derive(Debug)]
pub struct New<'a> {
pub name: &'a str,
}
impl Apply for New<'_> {
fn apply(self, state: &mut State) -> Result<(), CommandError> {
produce(state, |_| {
let mut file = File::default();
file.info.name = self.name.to_owned();
vec![file]
});
Ok(())
}
}
#[cfg(test)]
mod tests {
use crate::engine::command::fixture::Fixture;
use super::*;
#[test]
fn test_new() {
let mut fx = Fixture::default();
assert!(New { name: "new" }.apply(&mut fx.state()).is_ok());
assert_eq!(fx.files.len(), 1);
let file = fx.files.values().next().unwrap();
assert_eq!(file.info.name, "new");
assert!(file.trk.is_empty());
assert_eq!(fx.selected_files(), [file.id].into());
assert_eq!(fx.order.0, vec![file.id]);
}
}
@@ -1,21 +1,18 @@
use std::{collections::HashSet, hash::Hash}; use std::{collections::HashSet, hash::Hash};
use crate::{ use crate::{
Apply, ClipboardContent, CommandError, Destination, FileId, Place, RouteId, Selection, State, Apply, ClipboardContent, CommandError, Destination, FileId, Place, Selection, State, TrackId,
TrackId, TrackSegmentId, WaypointId, transfer, waypoint_ids, TrackSegmentId, WaypointId, transfer, waypoint_ids,
}; };
/// Pastes what was copied or cut (see [`crate::Clipboard`]). /// Pastes what was copied or cut (see [`crate::Clipboard`]).
/// ///
/// Where it goes depends on the selection, see [`crate::Clipboard::can_paste`]: /// Where it goes depends on the selection, see [`crate::Clipboard::can_paste`]:
/// - nothing selected: the files are copied, and routes, tracks and segments become new files /// - nothing selected: the files are copied, and tracks and segments become new files (named
/// (named like their route or track, or like the file they come from); /// like their track, or like the file they come from);
/// - a file: the routes and tracks are added to it, segments become new tracks in it, and the /// - a file: the tracks are added to it, segments become new tracks in it, and the waypoints are
/// waypoints are added to its own; /// added to its own;
/// - a route: routes, and segments as new routes, go after it in its file, tracks go before the /// - a track: the segments are added to it, tracks go after it in its file;
/// other tracks (right after the routes);
/// - a track: the segments are added to it, tracks go after it in its file, and routes after the
/// other routes;
/// - a segment: the segments go after it in its track; /// - a segment: the segments go after it in its track;
/// - the waypoints or a waypoint: the waypoints are added to their file, after the waypoint. /// - the waypoints or a waypoint: the waypoints are added to their file, after the waypoint.
/// ///
@@ -49,14 +46,6 @@ impl Apply for Paste {
} }
} }
fn route_ids_of(state: &State, file_id: FileId) -> Vec<RouteId> {
state
.files
.get(&file_id)
.map(|file| file.rte.iter().map(|rte| rte.id).collect())
.unwrap_or_default()
}
fn track_ids_of(state: &State, file_id: FileId) -> Vec<TrackId> { fn track_ids_of(state: &State, file_id: FileId) -> Vec<TrackId> {
state state
.files .files
@@ -90,34 +79,14 @@ fn destination(state: &State, content: &ClipboardContent) -> Result<Destination,
}; };
Ok(match (content, &*state.selection) { Ok(match (content, &*state.selection) {
(ClipboardContent::Files(_), _) => Destination::Files(Place::End), (ClipboardContent::Files(_), _) => Destination::Files(Place::End),
( (ClipboardContent::Tracks(_) | ClipboardContent::Segments(_), Selection::Empty) => {
ClipboardContent::Routes(_) Destination::Files(Place::End)
| ClipboardContent::Tracks(_)
| ClipboardContent::Segments(_),
Selection::Empty,
) => Destination::Files(Place::End),
(ClipboardContent::Routes(_), Selection::File { file_ids }) => {
Destination::Routes(last_file(file_ids)?, Place::End)
}
// routes and tracks keep their kind (see `Destination`)
(
ClipboardContent::Routes(_)
| ClipboardContent::Tracks(_)
| ClipboardContent::Segments(_),
Selection::Route { file_id, rte_ids },
) => {
let last =
last_selected(route_ids_of(state, *file_id).into_iter(), rte_ids).ok_or(nothing)?;
Destination::Routes(*file_id, Place::After(last))
} }
( (
ClipboardContent::Tracks(_) | ClipboardContent::Segments(_), ClipboardContent::Tracks(_) | ClipboardContent::Segments(_),
Selection::File { file_ids }, Selection::File { file_ids },
) => Destination::Tracks(last_file(file_ids)?, Place::End), ) => Destination::Tracks(last_file(file_ids)?, Place::End),
( (ClipboardContent::Tracks(_), Selection::Track { file_id, trk_ids }) => {
ClipboardContent::Routes(_) | ClipboardContent::Tracks(_),
Selection::Track { file_id, trk_ids },
) => {
let last = let last =
last_selected(track_ids_of(state, *file_id).into_iter(), trk_ids).ok_or(nothing)?; last_selected(track_ids_of(state, *file_id).into_iter(), trk_ids).ok_or(nothing)?;
Destination::Tracks(*file_id, Place::After(last)) Destination::Tracks(*file_id, Place::After(last))
@@ -171,8 +140,7 @@ mod tests {
use crate::{ use crate::{
Clipboard, ClipboardIds, File, FileId, Track, TrackId, TrackInfo, TrackSegment, Clipboard, ClipboardIds, File, FileId, Track, TrackId, TrackInfo, TrackSegment,
TrackSegmentId, Waypoint, WaypointId, Waypoints, engine::command::fixture::Fixture, TrackSegmentId, Waypoint, WaypointId, engine::command::fixture::Fixture, new_file,
new_file,
}; };
use super::*; use super::*;
@@ -194,10 +162,10 @@ mod tests {
.collect(), .collect(),
); );
if waypoints > 0 { if waypoints > 0 {
file.wpt = Waypoints::new([crate::WaypointChunk { file.wpt = vec![Rc::new(crate::WaypointChunk {
wpt: (0..waypoints).map(|_| Waypoint::default()).collect(), wpt: (0..waypoints).map(|_| Waypoint::default()).collect(),
..Default::default() ..Default::default()
}]); })];
} }
file file
} }
@@ -750,6 +718,8 @@ mod tests {
let a = add(&mut fx, file("a", &[(Some("t"), 2)], 2)); let a = add(&mut fx, file("a", &[(Some("t"), 2)], 2));
let b = add(&mut fx, file("b", &[], 0)); let b = add(&mut fx, file("b", &[], 0));
let t = track_ids(&fx, a); let t = track_ids(&fx, a);
let s = segment_ids(&fx, a, 0);
let w = wpt_ids(&fx, a);
copy(&mut fx, tracks(a, &t), false); copy(&mut fx, tracks(a, &t), false);
fx.selection = files(&[b]); fx.selection = files(&[b]);
@@ -765,7 +735,7 @@ mod tests {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
let a = add(&mut fx, file("a", &[(Some("t"), 2)], 2)); let a = add(&mut fx, file("a", &[(Some("t"), 2)], 2));
let b = add(&mut fx, file("b", &[], 0)); let b = add(&mut fx, file("b", &[], 0));
let (t, s) = (track_ids(&fx, a), segment_ids(&fx, a, 0)); let (t, s, w) = (track_ids(&fx, a), segment_ids(&fx, a, 0), wpt_ids(&fx, a));
copy(&mut fx, segments(a, t[0], &s), false); copy(&mut fx, segments(a, t[0], &s), false);
fx.selection = files(&[b]); fx.selection = files(&[b]);
delete_file(&mut fx, a); delete_file(&mut fx, a);
@@ -5,9 +5,9 @@
use std::{collections::HashSet, rc::Rc}; use std::{collections::HashSet, rc::Rc};
use crate::{ use crate::{
ClipboardContent, ClipboardRoute, ClipboardSegment, ClipboardTrack, CommandError, File, FileId, ClipboardContent, ClipboardSegment, ClipboardTrack, CommandError, File, FileId, Selection,
Route, RouteId, Selection, State, Track, TrackId, TrackSegment, TrackSegmentId, Waypoint, State, Track, TrackId, TrackSegment, TrackSegmentId, Waypoint, WaypointId, copy_file,
WaypointId, copy_file, copy_route, copy_segment, copy_track, copy_waypoint, copy_segment, copy_track, copy_waypoint, edit_waypoint_chunks, insert_waypoints_at,
}; };
/// Where elements are put, among the others of the same list. /// Where elements are put, among the others of the same list.
@@ -37,27 +37,25 @@ impl<T: Copy + PartialEq> Place<T> {
/// Where elements go. What can go where: /// Where elements go. What can go where:
/// - files: among the files; /// - files: among the files;
/// - routes: among the files (each route becomes a file, named like the route, or like the file
/// it comes from), or among the routes of a file. Among the tracks of a file, they stay routes,
/// which come before the tracks: they go after the other routes;
/// - tracks: among the files (each track becomes a file, named like the track, or like the file /// - tracks: among the files (each track becomes a file, named like the track, or like the file
/// it comes from), or among the tracks of a file. Among the routes of a file, they stay tracks, /// it comes from), or among the tracks of a file;
/// which come after the routes: they go before the other tracks;
/// - segments: among the files (each segment becomes a file with a track, named like its track, /// - segments: among the files (each segment becomes a file with a track, named like its track,
/// or like its file), among the routes or the tracks of a file (each segment becomes a route or /// or like its file), among the tracks of a file (each segment becomes a track), or among the
/// a track), or among the segments of a track; /// segments of a track;
/// - waypoints: among the waypoints of a file. /// - waypoints: among the waypoints of a file.
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
pub enum Destination { pub enum Destination {
Files(Place<FileId>), Files(Place<FileId>),
Routes(FileId, Place<RouteId>),
Tracks(FileId, Place<TrackId>), Tracks(FileId, Place<TrackId>),
Segments(FileId, TrackId, Place<TrackSegmentId>), Segments(FileId, TrackId, Place<TrackSegmentId>),
Waypoints(FileId, Place<WaypointId>), Waypoints(FileId, Place<WaypointId>),
} }
pub fn waypoint_ids(file: &File) -> impl Iterator<Item = WaypointId> + '_ { pub fn waypoint_ids(file: &File) -> impl Iterator<Item = WaypointId> + '_ {
file.wpt.iter().map(|wpt| wpt.id) file.wpt
.iter()
.flat_map(|chunk| &chunk.wpt)
.map(|wpt| wpt.id)
} }
fn file_mut<'a>(state: &'a mut State, id: FileId) -> Result<&'a mut File, CommandError> { fn file_mut<'a>(state: &'a mut State, id: FileId) -> Result<&'a mut File, CommandError> {
@@ -98,14 +96,6 @@ pub fn remove_elements(state: &mut State, content: &ClipboardContent) {
state.files.retain(|id, _| !ids.contains(id)); state.files.retain(|id, _| !ids.contains(id));
state.order.0.retain(|id| !ids.contains(id)); state.order.0.retain(|id| !ids.contains(id));
} }
ClipboardContent::Routes(routes) => {
let ids: HashSet<RouteId> = routes.iter().map(|rte| rte.route.id).collect();
for file in state.files.values_mut() {
if file.rte.iter().any(|rte| ids.contains(&rte.id)) {
Rc::make_mut(file).rte.retain(|rte| !ids.contains(&rte.id));
}
}
}
ClipboardContent::Tracks(tracks) => { ClipboardContent::Tracks(tracks) => {
let ids: HashSet<TrackId> = tracks.iter().map(|trk| trk.track.id).collect(); let ids: HashSet<TrackId> = tracks.iter().map(|trk| trk.track.id).collect();
for file in state.files.values_mut() { for file in state.files.values_mut() {
@@ -129,7 +119,8 @@ pub fn remove_elements(state: &mut State, content: &ClipboardContent) {
let ids: HashSet<WaypointId> = waypoints.iter().map(|wpt| wpt.id).collect(); let ids: HashSet<WaypointId> = waypoints.iter().map(|wpt| wpt.id).collect();
for file in state.files.values_mut() { for file in state.files.values_mut() {
if waypoint_ids(file).any(|id| ids.contains(&id)) { if waypoint_ids(file).any(|id| ids.contains(&id)) {
Rc::make_mut(file).wpt.edit( edit_waypoint_chunks(
Rc::make_mut(file),
|wpt| ids.contains(&wpt.id), |wpt| ids.contains(&wpt.id),
|wpts| { |wpts| {
wpts.retain(|wpt| !ids.contains(&wpt.id)); wpts.retain(|wpt| !ids.contains(&wpt.id));
@@ -154,34 +145,25 @@ pub fn transfer(
// the destination has to be there, before anything is changed // the destination has to be there, before anything is changed
let exists = match to { let exists = match to {
Destination::Files(_) => true, Destination::Files(_) => true,
Destination::Routes(file_id, _) | Destination::Tracks(file_id, _) => { Destination::Tracks(file_id, _) => state.files.contains_key(&file_id),
state.files.contains_key(&file_id)
}
Destination::Segments(file_id, trk_id, _) => state Destination::Segments(file_id, trk_id, _) => state
.files .files
.get(&file_id) .get(&file_id)
.is_some_and(|file| file.trk.iter().any(|trk| trk.id == trk_id)), .is_some_and(|file| file.trk.iter().any(|trk| trk.id == trk_id)),
Destination::Waypoints(file_id, _) => state.files.contains_key(&file_id), Destination::Waypoints(file_id, _) => state.files.contains_key(&file_id),
}; };
let valid = matches!( let valid = match (content, to) {
(content, to),
(ClipboardContent::Files(_), Destination::Files(_)) (ClipboardContent::Files(_), Destination::Files(_))
| ( | (ClipboardContent::Tracks(_), Destination::Files(_) | Destination::Tracks(..))
ClipboardContent::Routes(_) | ClipboardContent::Tracks(_), | (
Destination::Files(_) | Destination::Routes(..) | Destination::Tracks(..) ClipboardContent::Segments(_),
) Destination::Files(_) | Destination::Tracks(..) | Destination::Segments(..),
| ( )
ClipboardContent::Segments(_), | (ClipboardContent::Waypoints(_), Destination::Waypoints(..)) => true,
Destination::Files(_) _ => false,
| Destination::Routes(..) };
| Destination::Tracks(..)
| Destination::Segments(..),
)
| (ClipboardContent::Waypoints(_), Destination::Waypoints(..))
);
let empty = match content { let empty = match content {
ClipboardContent::Files(files) => files.is_empty(), ClipboardContent::Files(files) => files.is_empty(),
ClipboardContent::Routes(routes) => routes.is_empty(),
ClipboardContent::Tracks(tracks) => tracks.is_empty(), ClipboardContent::Tracks(tracks) => tracks.is_empty(),
ClipboardContent::Segments(segments) => segments.is_empty(), ClipboardContent::Segments(segments) => segments.is_empty(),
ClipboardContent::Waypoints(waypoints) => waypoints.is_empty(), ClipboardContent::Waypoints(waypoints) => waypoints.is_empty(),
@@ -208,7 +190,6 @@ pub fn transfer(
.collect(); .collect();
Ok(add_files(state, files, place)) Ok(add_files(state, files, place))
} }
(ClipboardContent::Routes(routes), to) => transfer_routes(state, routes, copy, to),
(ClipboardContent::Tracks(tracks), to) => transfer_tracks(state, tracks, copy, to), (ClipboardContent::Tracks(tracks), to) => transfer_tracks(state, tracks, copy, to),
(ClipboardContent::Segments(segments), to) => transfer_segments(state, segments, copy, to), (ClipboardContent::Segments(segments), to) => transfer_segments(state, segments, copy, to),
(ClipboardContent::Waypoints(waypoints), Destination::Waypoints(file_id, place)) => { (ClipboardContent::Waypoints(waypoints), Destination::Waypoints(file_id, place)) => {
@@ -218,89 +199,6 @@ pub fn transfer(
} }
} }
/// Puts the routes among the routes of a file, at `place`, and gives the selection of them.
fn insert_routes(
state: &mut State,
file_id: FileId,
place: Place<RouteId>,
routes: Vec<Route>,
) -> Result<Selection, CommandError> {
let ids: HashSet<RouteId> = routes.iter().map(|rte| rte.id).collect();
let file = file_mut(state, file_id)?;
let existing: Vec<RouteId> = file.rte.iter().map(|rte| rte.id).collect();
let at = place.position(&existing);
file.rte.splice(at..at, routes);
Ok(Selection::Route {
file_id,
rte_ids: ids,
})
}
fn transfer_routes(
state: &mut State,
routes: &[ClipboardRoute],
copy: bool,
to: Destination,
) -> Result<Selection, CommandError> {
let routes: Vec<(Route, &str)> = routes
.iter()
.map(|clip| {
let route = if copy {
copy_route(&clip.route)
} else {
clip.route.clone()
};
(route, clip.file_name.as_str())
})
.collect();
match to {
Destination::Files(place) => {
let files = routes
.into_iter()
.map(|(route, file_name)| {
let name = route
.info
.name
.clone()
.unwrap_or_else(|| file_name.to_owned());
Rc::new(File {
rte: vec![route],
..new_file(&name, vec![])
})
})
.collect();
Ok(add_files(state, files, place))
}
Destination::Routes(file_id, place) => {
let routes = routes.into_iter().map(|(route, _)| route).collect();
insert_routes(state, file_id, place, routes)
}
Destination::Tracks(file_id, _) => {
let routes = routes.into_iter().map(|(route, _)| route).collect();
insert_routes(state, file_id, Place::End, routes)
}
_ => Err(CommandError::NothingToDo),
}
}
/// Puts the tracks among the tracks of a file, at `place`, and gives the selection of them.
fn insert_tracks(
state: &mut State,
file_id: FileId,
place: Place<TrackId>,
tracks: Vec<Track>,
) -> Result<Selection, CommandError> {
let ids: HashSet<TrackId> = tracks.iter().map(|trk| trk.id).collect();
let file = file_mut(state, file_id)?;
let existing: Vec<TrackId> = file.trk.iter().map(|trk| trk.id).collect();
let at = place.position(&existing);
file.trk.splice(at..at, tracks);
Ok(Selection::Track {
file_id,
trk_ids: ids,
})
}
fn transfer_tracks( fn transfer_tracks(
state: &mut State, state: &mut State,
tracks: &[ClipboardTrack], tracks: &[ClipboardTrack],
@@ -334,12 +232,16 @@ fn transfer_tracks(
Ok(add_files(state, files, place)) Ok(add_files(state, files, place))
} }
Destination::Tracks(file_id, place) => { Destination::Tracks(file_id, place) => {
let tracks = tracks.into_iter().map(|(track, _)| track).collect(); let tracks: Vec<Track> = tracks.into_iter().map(|(track, _)| track).collect();
insert_tracks(state, file_id, place, tracks) let ids: HashSet<TrackId> = tracks.iter().map(|trk| trk.id).collect();
} let file = file_mut(state, file_id)?;
Destination::Routes(file_id, _) => { let existing: Vec<TrackId> = file.trk.iter().map(|trk| trk.id).collect();
let tracks = tracks.into_iter().map(|(track, _)| track).collect(); let at = place.position(&existing);
insert_tracks(state, file_id, Place::Index(0), tracks) file.trk.splice(at..at, tracks);
Ok(Selection::Track {
file_id,
trk_ids: ids,
})
} }
_ => Err(CommandError::NothingToDo), _ => Err(CommandError::NothingToDo),
} }
@@ -375,22 +277,20 @@ fn transfer_segments(
.collect(); .collect();
Ok(add_files(state, files, place)) Ok(add_files(state, files, place))
} }
Destination::Routes(file_id, place) => {
let routes = segments
.into_iter()
.map(|(seg, _)| Route {
seg,
..Default::default()
})
.collect();
insert_routes(state, file_id, place, routes)
}
Destination::Tracks(file_id, place) => { Destination::Tracks(file_id, place) => {
let tracks = segments let tracks: Vec<Track> = segments
.into_iter() .into_iter()
.map(|(segment, _)| own_track(segment)) .map(|(segment, _)| own_track(segment))
.collect(); .collect();
insert_tracks(state, file_id, place, tracks) let ids = tracks.iter().map(|trk| trk.id).collect();
let file = file_mut(state, file_id)?;
let existing: Vec<TrackId> = file.trk.iter().map(|trk| trk.id).collect();
let at = place.position(&existing);
file.trk.splice(at..at, tracks);
Ok(Selection::Track {
file_id,
trk_ids: ids,
})
} }
Destination::Segments(file_id, trk_id, place) => { Destination::Segments(file_id, trk_id, place) => {
let segments: Vec<TrackSegment> = let segments: Vec<TrackSegment> =
@@ -434,7 +334,7 @@ fn transfer_waypoints(
let ids = waypoints.iter().map(|wpt| wpt.id).collect(); let ids = waypoints.iter().map(|wpt| wpt.id).collect();
let file = file_mut(state, file_id)?; let file = file_mut(state, file_id)?;
let existing: Vec<WaypointId> = waypoint_ids(file).collect(); let existing: Vec<WaypointId> = waypoint_ids(file).collect();
file.wpt.insert_at(place.position(&existing), waypoints); insert_waypoints_at(file, place.position(&existing), waypoints);
Ok(Selection::Waypoint { Ok(Selection::Waypoint {
file_id, file_id,
wpt_ids: ids, wpt_ids: ids,
@@ -2,11 +2,11 @@
use std::collections::HashSet; use std::collections::HashSet;
use crate::{Clipboard, FileId, FileOrder, Files, Selection, State, TrackpointCategories}; use crate::{Clipboard, FileId, FileOrder, Selection, StackEntry, State, TrackpointCategories};
#[derive(Default)] #[derive(Default)]
pub struct Fixture { pub struct Fixture {
pub files: Files, pub files: StackEntry,
pub selection: Selection, pub selection: Selection,
pub order: FileOrder, pub order: FileOrder,
pub clipboard: Option<Clipboard>, pub clipboard: Option<Clipboard>,
+15
View File
@@ -0,0 +1,15 @@
mod apply;
mod command;
mod edit;
mod file;
#[cfg(test)]
pub(crate) mod fixture;
mod pattern;
mod tools;
pub use apply::*;
pub use command::*;
pub use edit::*;
pub use file::*;
pub use pattern::*;
pub use tools::*;
@@ -1,4 +1,4 @@
use crate::{File, Route, Track, TrackSegment, Waypoint}; use crate::{File, Track, TrackSegment, Waypoint};
// The trackpoints of a segment are shared chunks, so copying elements is cheap. // The trackpoints of a segment are shared chunks, so copying elements is cheap.
@@ -18,20 +18,10 @@ pub fn copy_track(track: &Track) -> Track {
} }
} }
/// A copy of the route and of its segment, with new ids. /// A copy of the file and of its tracks and segments, with new ids.
pub fn copy_route(route: &Route) -> Route {
Route {
id: Default::default(),
seg: copy_segment(&route.seg),
..route.clone()
}
}
/// A copy of the file and of its routes, tracks and segments, with new ids.
pub fn copy_file(file: &File) -> File { pub fn copy_file(file: &File) -> File {
File { File {
id: Default::default(), id: Default::default(),
rte: file.rte.iter().map(copy_route).collect(),
trk: file.trk.iter().map(copy_track).collect(), trk: file.trk.iter().map(copy_track).collect(),
..file.clone() ..file.clone()
} }
@@ -0,0 +1,40 @@
use std::rc::Rc;
use crate::{File, Waypoint, WaypointChunk};
/// Edits the waypoints of the chunks containing a waypoint accepted by `filter`.
///
/// `f` receives a copy of the chunk's waypoints and returns whether it changed them. A
/// changed chunk is replaced by a new one (with a new id, so that derived data is recomputed)
/// and chunks left empty are dropped. Returns whether anything changed.
pub fn edit_waypoint_chunks(
file: &mut File,
filter: impl Fn(&Waypoint) -> bool,
mut f: impl FnMut(&mut Vec<Waypoint>) -> bool,
) -> bool {
let mut changed = false;
let mut chunks = Vec::with_capacity(file.wpt.len());
for chunk in file.wpt.drain(..) {
if !chunk.wpt.iter().any(&filter) {
chunks.push(chunk);
continue;
}
let mut wpt = chunk.wpt.clone();
if !f(&mut wpt) {
chunks.push(chunk);
continue;
}
changed = true;
if !wpt.is_empty() {
chunks.push(Rc::new(WaypointChunk {
wpt,
..Default::default()
}));
}
}
file.wpt = chunks;
if changed {
file.wpt_rev_id = Default::default();
}
changed
}
@@ -0,0 +1,218 @@
use std::rc::Rc;
use crate::{File, Waypoint, WaypointChunk, WaypointId};
/// Inserts waypoints in the file, right after the waypoint `after`, or at the end if there is
/// none (or if it is not in the file).
///
/// See [`insert_waypoints_at`].
pub fn insert_waypoints(file: &mut File, after: Option<WaypointId>, waypoints: Vec<Waypoint>) {
let index = after
.and_then(|after| {
file.wpt
.iter()
.flat_map(|chunk| &chunk.wpt)
.position(|wpt| wpt.id == after)
})
.map_or(usize::MAX, |i| i + 1);
insert_waypoints_at(file, index, waypoints);
}
/// Inserts waypoints in the file, so that the first one is at `index` among the waypoints of
/// the file (at the end if the index is past it).
///
/// Only the chunk holding the waypoint that was at `index` is cut (when the waypoints are not
/// inserted between two chunks), all the other chunks are kept as they are.
pub fn insert_waypoints_at(file: &mut File, index: usize, waypoints: Vec<Waypoint>) {
if waypoints.is_empty() {
return;
}
let mut inserted = Vec::new();
let mut chunk = WaypointChunk::default();
for wpt in waypoints {
chunk.wpt.push(wpt);
if chunk.is_full() {
inserted.push(Rc::new(std::mem::take(&mut chunk)));
}
}
if !chunk.wpt.is_empty() {
inserted.push(Rc::new(chunk));
}
// the chunk holding the waypoint at `index`, and the position of that waypoint in it
let mut start = 0;
let position = file.wpt.iter().enumerate().find_map(|(i, chunk)| {
let offset = index
.checked_sub(start)
.filter(|offset| *offset < chunk.wpt.len());
start += chunk.wpt.len();
offset.map(|offset| (i, offset))
});
match position {
None => file.wpt.extend(inserted),
Some((i, 0)) => {
file.wpt.splice(i..i, inserted);
}
Some((i, offset)) => {
let cut = &file.wpt[i];
let part = |wpt: &[Waypoint]| {
Rc::new(WaypointChunk {
wpt: wpt.to_vec(),
..Default::default()
})
};
let mut chunks = vec![part(&cut.wpt[..offset])];
chunks.extend(inserted);
chunks.push(part(&cut.wpt[offset..]));
file.wpt.splice(i..=i, chunks);
}
}
file.wpt_rev_id = Default::default();
}
#[cfg(test)]
mod tests {
use super::*;
fn waypoint() -> Waypoint {
Waypoint::default()
}
fn file_with(chunks: &[usize]) -> (File, Vec<WaypointId>) {
let mut file = File::default();
let mut ids = vec![];
for n in chunks {
let wpt: Vec<_> = (0..*n).map(|_| waypoint()).collect();
ids.extend(wpt.iter().map(|w| w.id));
file.wpt.push(Rc::new(WaypointChunk {
wpt,
..Default::default()
}));
}
(file, ids)
}
fn ids(file: &File) -> Vec<WaypointId> {
file.wpt
.iter()
.flat_map(|chunk| chunk.wpt.iter().map(|w| w.id))
.collect()
}
#[test]
fn test_insert_at_the_end() {
let (mut file, before) = file_with(&[2, 1]);
let rev = file.wpt_rev_id;
let new = vec![waypoint(), waypoint()];
let new_ids: Vec<_> = new.iter().map(|w| w.id).collect();
insert_waypoints(&mut file, None, new);
assert_eq!(ids(&file), [before.clone(), new_ids].concat());
// the chunks that were there are kept
assert_eq!(file.wpt.len(), 3);
assert_ne!(file.wpt_rev_id, rev);
// an unknown waypoint is an insertion at the end too
let (mut file, before) = file_with(&[2]);
let one = waypoint();
let one_id = one.id;
insert_waypoints(&mut file, Some(WaypointId::default()), vec![one]);
assert_eq!(ids(&file), [before, vec![one_id]].concat());
}
#[test]
fn test_insert_after_the_last_waypoint_of_a_chunk_keeps_the_chunks() {
let (mut file, before) = file_with(&[2, 2]);
let first = file.wpt[0].clone();
let one = waypoint();
let one_id = one.id;
insert_waypoints(&mut file, Some(before[1]), vec![one]);
assert_eq!(ids(&file), [&before[..2], &[one_id], &before[2..]].concat());
// 2 chunks + the inserted one, nothing was cut
assert_eq!(file.wpt.len(), 3);
assert!(Rc::ptr_eq(&file.wpt[0], &first));
}
#[test]
fn test_insert_in_the_middle_of_a_chunk_cuts_it() {
let (mut file, before) = file_with(&[3, 1]);
let last = file.wpt[1].clone();
let new = vec![waypoint(), waypoint()];
let new_ids: Vec<_> = new.iter().map(|w| w.id).collect();
insert_waypoints(&mut file, Some(before[0]), new);
assert_eq!(
ids(&file),
[&before[..1], &new_ids[..], &before[1..]].concat()
);
// the cut chunk, the inserted one and the end of the cut one, then the untouched chunk
assert_eq!(file.wpt.len(), 4);
assert!(Rc::ptr_eq(&file.wpt[3], &last));
}
#[test]
fn test_insert_nothing() {
let (mut file, before) = file_with(&[2]);
let rev = file.wpt_rev_id;
insert_waypoints(&mut file, Some(before[0]), vec![]);
assert_eq!(ids(&file), before);
assert_eq!(file.wpt_rev_id, rev);
}
#[test]
fn test_insert_many_fills_chunks() {
let mut file = File::default();
let new: Vec<_> = (0..300).map(|_| waypoint()).collect();
let new_ids: Vec<_> = new.iter().map(|w| w.id).collect();
insert_waypoints(&mut file, None, new);
assert_eq!(ids(&file), new_ids);
assert_eq!(file.wpt.len(), 3);
assert!(file.wpt[..2].iter().all(|chunk| chunk.is_full()));
}
#[test]
fn test_insert_at_an_index() {
// at the start
let (mut file, before) = file_with(&[2, 1]);
let first = file.wpt[0].clone();
let one = waypoint();
let one_id = one.id;
insert_waypoints_at(&mut file, 0, vec![one]);
assert_eq!(ids(&file), [vec![one_id], before.clone()].concat());
// the existing chunks are kept
assert_eq!(file.wpt.len(), 3);
assert!(Rc::ptr_eq(&file.wpt[1], &first));
// between two chunks
let (mut file, before) = file_with(&[2, 1]);
let (first, last) = (file.wpt[0].clone(), file.wpt[1].clone());
let one = waypoint();
let one_id = one.id;
insert_waypoints_at(&mut file, 2, vec![one]);
assert_eq!(ids(&file), [&before[..2], &[one_id], &before[2..]].concat());
assert_eq!(file.wpt.len(), 3);
assert!(Rc::ptr_eq(&file.wpt[0], &first) && Rc::ptr_eq(&file.wpt[2], &last));
// inside a chunk
let (mut file, before) = file_with(&[3]);
let one = waypoint();
let one_id = one.id;
insert_waypoints_at(&mut file, 1, vec![one]);
assert_eq!(ids(&file), [&before[..1], &[one_id], &before[1..]].concat());
assert_eq!(file.wpt.len(), 3);
// at the end, or past it
for index in [3, 100] {
let (mut file, before) = file_with(&[3]);
let one = waypoint();
let one_id = one.id;
insert_waypoints_at(&mut file, index, vec![one]);
assert_eq!(ids(&file), [before, vec![one_id]].concat());
}
// in a file without waypoints
let mut file = File::default();
let one = waypoint();
let one_id = one.id;
insert_waypoints_at(&mut file, 0, vec![one]);
assert_eq!(ids(&file), vec![one_id]);
}
}
@@ -1,11 +1,13 @@
mod copy; mod copy;
mod edit_waypoint_chunks;
mod insert_waypoints;
mod produce; mod produce;
mod update_segments;
mod update_selected; mod update_selected;
mod update_waypoint; mod update_waypoint;
pub use copy::*; pub use copy::*;
pub use edit_waypoint_chunks::*;
pub use insert_waypoints::*;
pub use produce::*; pub use produce::*;
pub use update_segments::*;
pub use update_selected::*; pub use update_selected::*;
pub use update_waypoint::*; pub use update_waypoint::*;
@@ -1,6 +1,8 @@
use std::rc::Rc; use std::rc::Rc;
use crate::{File, FileId, Files, Route, Selection, State, Track, TrackSegment, Waypoint}; use crate::{
File, FileId, Selection, StackEntry, State, Track, TrackSegment, Waypoint, edit_waypoint_chunks,
};
/// What an [`Editor`] hook did to the element it was given. /// What an [`Editor`] hook did to the element it was given.
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -21,19 +23,13 @@ impl Edit {
/// Independent edit of each selected element, without needing the rest of the state. /// Independent edit of each selected element, without needing the rest of the state.
/// ///
/// A selected file, route, track or segment is passed to the hook of its own level. By default /// A selected file, track or segment is passed to the hook of its own level. By default a
/// a file is forwarded to its routes and tracks, and a route or a track to its segments, so an /// file is forwarded to its tracks and a track to its segments, so an editor only overrides
/// editor only overrides the level(s) it cares about (metadata: file, route and track, style: /// the level(s) it cares about (metadata: file and track, style: track, reverse: segment).
/// route and track, reverse: segment). Waypoints are only edited when selected, never through /// Waypoints are only edited when selected, never through their file.
/// their file.
pub trait Editor { pub trait Editor {
fn file(&mut self, file: &mut File) -> Edit { fn file(&mut self, file: &mut File) -> Edit {
let routes = edit_each(&mut file.rte, |rte| self.route(rte)); edit_each(&mut file.trk, |trk| self.track(trk))
routes.merge(edit_each(&mut file.trk, |trk| self.track(trk)))
}
fn route(&mut self, route: &mut Route) -> Edit {
edit_segment(self, &mut route.seg)
} }
fn track(&mut self, track: &mut Track) -> Edit { fn track(&mut self, track: &mut Track) -> Edit {
@@ -76,7 +72,7 @@ fn edit_where<T>(
/// Edits a copy of the file (cheap, track points are shared chunks) and stores it back as a /// Edits a copy of the file (cheap, track points are shared chunks) and stores it back as a
/// new snapshot only if something changed. /// new snapshot only if something changed.
fn update_file(files: &mut Files, id: FileId, f: impl FnOnce(&mut File) -> Edit) { fn update_file(files: &mut StackEntry, id: FileId, f: impl FnOnce(&mut File) -> Edit) {
let Some(current) = files.get(&id) else { let Some(current) = files.get(&id) else {
return; return;
}; };
@@ -91,7 +87,7 @@ fn edit_waypoints<E: Editor + ?Sized>(
filter: impl Fn(&Waypoint) -> bool, filter: impl Fn(&Waypoint) -> bool,
editor: &mut E, editor: &mut E,
) -> Edit { ) -> Edit {
let changed = file.wpt.edit(&filter, |wpts| { let changed = edit_waypoint_chunks(file, &filter, |wpts| {
edit_where(wpts, &filter, |wpt| editor.waypoint(wpt)) == Edit::Changed edit_where(wpts, &filter, |wpt| editor.waypoint(wpt)) == Edit::Changed
}); });
if changed { if changed {
@@ -101,7 +97,7 @@ fn edit_waypoints<E: Editor + ?Sized>(
} }
} }
/// Applies the editor to every selected file, route, track or segment. /// Applies the editor to every selected file, track or segment.
pub fn update_selected<E: Editor>(state: &mut State, editor: &mut E) { pub fn update_selected<E: Editor>(state: &mut State, editor: &mut E) {
match &*state.selection { match &*state.selection {
Selection::File { file_ids } => { Selection::File { file_ids } => {
@@ -109,15 +105,6 @@ pub fn update_selected<E: Editor>(state: &mut State, editor: &mut E) {
update_file(state.files, *id, |file| editor.file(file)); update_file(state.files, *id, |file| editor.file(file));
} }
} }
Selection::Route { file_id, rte_ids } => {
update_file(state.files, *file_id, |file| {
edit_where(
&mut file.rte,
|rte| rte_ids.contains(&rte.id),
|rte| editor.route(rte),
)
});
}
Selection::Track { file_id, trk_ids } => { Selection::Track { file_id, trk_ids } => {
update_file(state.files, *file_id, |file| { update_file(state.files, *file_id, |file| {
edit_where( edit_where(
@@ -300,34 +287,35 @@ mod tests {
let wpts: Vec<_> = (0..3).map(|_| Waypoint::default()).collect(); let wpts: Vec<_> = (0..3).map(|_| Waypoint::default()).collect();
let ids: Vec<_> = wpts.iter().map(|w| w.id).collect(); let ids: Vec<_> = wpts.iter().map(|w| w.id).collect();
let mut file = (*fx.files[&id]).clone(); let mut file = (*fx.files[&id]).clone();
file.wpt = crate::Waypoints::new([crate::WaypointChunk { file.wpt = vec![Rc::new(crate::WaypointChunk {
wpt: wpts, wpt: wpts,
..Default::default() ..Default::default()
}]); })];
fx.files.insert(id, Rc::new(file)); fx.files.insert(id, Rc::new(file));
let chunk_id = fx.files[&id].wpt.chunks()[0].id; let chunk_id = fx.files[&id].wpt[0].id;
// A file selection never touches waypoints. // A file selection never touches waypoints.
fx.selection = Selection::File { fx.selection = Selection::File {
file_ids: HashSet::from([id]), file_ids: HashSet::from([id]),
}; };
update_selected(&mut fx.state(), &mut Name); update_selected(&mut fx.state(), &mut Name);
assert!(fx.files[&id].wpt.iter().all(|w| w.name.is_none())); assert!(fx.files[&id].wpt[0].wpt.iter().all(|w| w.name.is_none()));
fx.selection = Selection::Waypoint { fx.selection = Selection::Waypoint {
file_id: id, file_id: id,
wpt_ids: HashSet::from([ids[1]]), wpt_ids: HashSet::from([ids[1]]),
}; };
let rev = fx.files[&id].wpt.rev_id; let rev = fx.files[&id].wpt_rev_id;
update_selected(&mut fx.state(), &mut Name); update_selected(&mut fx.state(), &mut Name);
assert_ne!(fx.files[&id].wpt.rev_id, rev); assert_ne!(fx.files[&id].wpt_rev_id, rev);
assert_ne!(fx.files[&id].wpt.chunks()[0].id, chunk_id); let chunk = &fx.files[&id].wpt[0];
let named: Vec<_> = fx.files[&id].wpt.iter().map(|w| w.name.is_some()).collect(); assert_ne!(chunk.id, chunk_id);
let named: Vec<_> = chunk.wpt.iter().map(|w| w.name.is_some()).collect();
assert_eq!(named, [false, true, false]); assert_eq!(named, [false, true, false]);
fx.selection = Selection::Waypoints { file_id: id }; fx.selection = Selection::Waypoints { file_id: id };
update_selected(&mut fx.state(), &mut Name); update_selected(&mut fx.state(), &mut Name);
assert!(fx.files[&id].wpt.iter().all(|w| w.name.is_some())); assert!(fx.files[&id].wpt[0].wpt.iter().all(|w| w.name.is_some()));
} }
#[test] #[test]
@@ -1,6 +1,6 @@
use std::rc::Rc; use std::rc::Rc;
use crate::{CommandError, FileId, State, Waypoint, WaypointId}; use crate::{CommandError, FileId, State, Waypoint, WaypointId, edit_waypoint_chunks};
/// Changes one waypoint of a file with `f`, whatever is selected. Nothing to do if the file or /// Changes one waypoint of a file with `f`, whatever is selected. Nothing to do if the file or
/// the waypoint does not exist. /// the waypoint does not exist.
@@ -12,7 +12,8 @@ pub fn update_waypoint(
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
let file = state.files.get(&file_id).ok_or(CommandError::NothingToDo)?; let file = state.files.get(&file_id).ok_or(CommandError::NothingToDo)?;
let mut file = (**file).clone(); let mut file = (**file).clone();
let changed = file.wpt.edit( let changed = edit_waypoint_chunks(
&mut file,
|wpt| wpt.id == waypoint_id, |wpt| wpt.id == waypoint_id,
|wpts| { |wpts| {
wpts.iter_mut() wpts.iter_mut()
@@ -2,19 +2,19 @@ use std::{collections::HashSet, rc::Rc};
use crate::{ use crate::{
Apply, CommandError, Edit, Editor, File, FileId, LngLat, LngLatBounds, Selection, State, Apply, CommandError, Edit, Editor, File, FileId, LngLat, LngLatBounds, Selection, State,
TrackSegment, TrackSegmentId, Trackpoint, Waypoint, delete_waypoints, update_selected, TrackSegment, TrackSegmentId, Trackpoint, Waypoint, delete_waypoints, edit_waypoint_chunks,
update_selected,
}; };
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Deserialize)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub enum CleanType { pub enum CleanType {
Inside, Inside,
Outside, Outside,
} }
/// Removes the trackpoints and/or waypoints of the selection lying inside (or outside) a /// Removes the trackpoints and/or waypoints of the selection lying inside (or outside) a
/// rectangle. A selected file cleans its routes, its tracks and its waypoints, a selected route, /// rectangle. A selected file cleans its tracks and its waypoints, a selected track or segment
/// track or segment only trackpoints, selected waypoints only waypoints. /// only trackpoints, selected waypoints only waypoints.
#[derive(Debug)] #[derive(Debug)]
pub struct Clean { pub struct Clean {
pub bounds: LngLatBounds, pub bounds: LngLatBounds,
@@ -85,18 +85,14 @@ struct Cleaner<'a> {
impl Editor for Cleaner<'_> { impl Editor for Cleaner<'_> {
fn file(&mut self, file: &mut File) -> Edit { fn file(&mut self, file: &mut File) -> Edit {
let mut edit = Edit::Unchanged; let mut edit = Edit::Unchanged;
for rte in &mut file.rte {
if self.route(rte) == Edit::Changed {
edit = Edit::Changed;
}
}
for trk in &mut file.trk { for trk in &mut file.trk {
if self.track(trk) == Edit::Changed { if self.track(trk) == Edit::Changed {
edit = Edit::Changed; edit = Edit::Changed;
} }
} }
if self.clean.wpt if self.clean.wpt
&& file.wpt.edit( && edit_waypoint_chunks(
file,
|wpt| self.clean.removes(wpt.coordinates), |wpt| self.clean.removes(wpt.coordinates),
|wpts| { |wpts| {
wpts.retain(|wpt| !self.clean.removes(wpt.coordinates)); wpts.retain(|wpt| !self.clean.removes(wpt.coordinates));
@@ -129,27 +125,36 @@ impl Editor for Cleaner<'_> {
} }
} }
/// Removes what the clean left empty: the emptied segments, the routes of these segments and the /// Removes what the clean left empty: the emptied segments, the tracks that lost all their
/// tracks that lost all their segments. A file is never removed, even if nothing is left in it: it stays, empty. The /// segments and the files that lost something and have nothing left. The selection falls back
/// selection falls back to the closest element still existing. /// to the closest element still existing.
fn prune(state: &mut State, emptied: &HashSet<TrackSegmentId>, wpt_files: &HashSet<FileId>) { fn prune(state: &mut State, emptied: &HashSet<TrackSegmentId>, wpt_files: &HashSet<FileId>) {
let ids: Vec<FileId> = state let ids: Vec<FileId> = state
.files .files
.iter() .iter()
.filter(|(id, file)| { .filter(|(id, file)| {
wpt_files.contains(id) || file.segments().any(|seg| emptied.contains(&seg.id)) wpt_files.contains(id)
|| file
.trk
.iter()
.any(|trk| trk.trkseg.iter().any(|seg| emptied.contains(&seg.id)))
}) })
.map(|(id, _)| *id) .map(|(id, _)| *id)
.collect(); .collect();
for id in ids { for id in ids {
let mut file = (*state.files[&id]).clone(); let mut file = (*state.files[&id]).clone();
file.rte.retain(|rte| !emptied.contains(&rte.seg.id)); let lost_something = !emptied.is_empty() || wpt_files.contains(&id);
file.trk.retain_mut(|trk| { file.trk.retain_mut(|trk| {
let len = trk.trkseg.len(); let len = trk.trkseg.len();
trk.trkseg.retain(|seg| !emptied.contains(&seg.id)); trk.trkseg.retain(|seg| !emptied.contains(&seg.id));
trk.trkseg.len() == len || !trk.trkseg.is_empty() trk.trkseg.len() == len || !trk.trkseg.is_empty()
}); });
state.files.insert(id, Rc::new(file)); if lost_something && file.trk.is_empty() && file.wpt.is_empty() {
state.files.remove(&id);
state.order.0.retain(|f| *f != id);
} else {
state.files.insert(id, Rc::new(file));
}
} }
*state.selection = fixed_selection(state); *state.selection = fixed_selection(state);
} }
@@ -169,27 +174,6 @@ fn fixed_selection(state: &State) -> Selection {
Selection::File { file_ids } Selection::File { file_ids }
} }
} }
Selection::Route { file_id, rte_ids } => {
let Some(file) = files.get(file_id) else {
return Selection::Empty;
};
let rte_ids: HashSet<_> = file
.rte
.iter()
.map(|rte| rte.id)
.filter(|id| rte_ids.contains(id))
.collect();
if rte_ids.is_empty() {
Selection::File {
file_ids: [*file_id].into(),
}
} else {
Selection::Route {
file_id: *file_id,
rte_ids,
}
}
}
Selection::Track { file_id, trk_ids } => { Selection::Track { file_id, trk_ids } => {
let Some(file) = files.get(file_id) else { let Some(file) = files.get(file_id) else {
return Selection::Empty; return Selection::Empty;
@@ -260,7 +244,7 @@ fn fixed_selection(state: &State) -> Selection {
mod tests { mod tests {
use std::collections::HashSet; use std::collections::HashSet;
use crate::{FileId, Load, WaypointChunk, Waypoints, engine::command::fixture::Fixture}; use crate::{FileId, Load, engine::command::fixture::Fixture};
use super::*; use super::*;
@@ -314,16 +298,10 @@ mod tests {
.apply(&mut fx.state()) .apply(&mut fx.state())
.unwrap(); .unwrap();
assert_eq!(count(&fx, id), 0); assert_eq!(count(&fx, id), 0);
// nothing is left in the file, which stays and is still selected // nothing is left of the file
let file = &fx.files[&id]; assert!(!fx.files.contains_key(&id));
assert!(file.trk.is_empty() && file.wpt.is_empty()); assert!(fx.order.0.is_empty());
assert_eq!(fx.order.0, [id]); assert_eq!(fx.selection, Selection::Empty);
assert_eq!(
fx.selection,
Selection::File {
file_ids: HashSet::from([id])
}
);
} }
#[test] #[test]
@@ -353,8 +331,7 @@ mod tests {
let result = let result =
clean(bounds(-180.0, -90.0, 180.0, 90.0), CleanType::Outside).apply(&mut fx.state()); clean(bounds(-180.0, -90.0, 180.0, 90.0), CleanType::Outside).apply(&mut fx.state());
assert!(matches!(result, Err(CommandError::NothingToDo))); assert!(matches!(result, Err(CommandError::NothingToDo)));
// the file was not even copied assert_eq!(fx.files[&id], before);
assert!(std::rc::Rc::ptr_eq(&fx.files[&id], &before));
} }
#[test] #[test]
@@ -386,14 +363,18 @@ mod tests {
fn test_waypoints_flag_and_selection() { fn test_waypoints_flag_and_selection() {
let (mut fx, id) = loaded(); let (mut fx, id) = loaded();
let mut file = (*fx.files[&id]).clone(); let mut file = (*fx.files[&id]).clone();
file.wpt = Waypoints::new([WaypointChunk { file.wpt = vec![std::rc::Rc::new(crate::WaypointChunk {
wpt: vec![Waypoint::default(), Waypoint::default()], wpt: vec![Waypoint::default(), Waypoint::default()],
..Default::default() ..Default::default()
}]); })];
let ids: Vec<_> = file.wpt.iter().map(|w| w.id).collect(); let ids: Vec<_> = file.wpt[0].wpt.iter().map(|w| w.id).collect();
fx.files.insert(id, std::rc::Rc::new(file)); fx.files.insert(id, std::rc::Rc::new(file));
let everywhere = bounds(-180.0, -90.0, 180.0, 90.0); let everywhere = bounds(-180.0, -90.0, 180.0, 90.0);
let wpt_count = |fx: &Fixture| fx.files.get(&id).map_or(0, |f| f.wpt.len()); let wpt_count = |fx: &Fixture| {
fx.files
.get(&id)
.map_or(0, |f| f.wpt.iter().map(|c| c.wpt.len()).sum::<usize>())
};
// trackpoints only: waypoints are kept // trackpoints only: waypoints are kept
Clean { Clean {
@@ -0,0 +1,14 @@
use crate::{Apply, CommandError, State};
#[derive(Debug)]
pub struct Crop {
pub start: u32,
pub end: u32,
}
impl Apply for Crop {
fn apply(self, _state: &mut State) -> Result<(), CommandError> {
// TODO
Err(CommandError::NotImplemented("crop"))
}
}
@@ -45,23 +45,17 @@ mod tests {
fn test_edit_the_given_waypoint() { fn test_edit_the_given_waypoint() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
let mut file = File::default(); let mut file = File::default();
file.wpt.push(WaypointChunk { file.wpt.push(Rc::new(WaypointChunk {
wpt: vec![ wpt: vec![
Waypoint { Waypoint {
name: Some("old".into()), name: Some("old".into()),
desc: Some("old description".into()), desc: Some("old description".into()),
cmt: Some("old comment".into()), cmt: Some("old comment".into()),
sym: Some("Flag".into()), sym: Some("Flag".into()),
links: vec![ link: Some(Link {
Link { href: "https://old".into(),
href: "https://old".into(), text: None,
text: None, }),
},
Link {
href: "https://second".into(),
text: Some("second".into()),
},
],
..Default::default() ..Default::default()
}, },
Waypoint { Waypoint {
@@ -70,7 +64,7 @@ mod tests {
}, },
], ],
..Default::default() ..Default::default()
}); }));
let id = file.id; let id = file.id;
let ids: Vec<_> = waypoint_ids(&file).collect(); let ids: Vec<_> = waypoint_ids(&file).collect();
fx.files.insert(id, Rc::new(file)); fx.files.insert(id, Rc::new(file));
@@ -89,16 +83,19 @@ mod tests {
.apply(&mut fx.state()) .apply(&mut fx.state())
.unwrap(); .unwrap();
let wpts: Vec<_> = fx.files[&id].wpt.iter().collect(); let wpts: Vec<_> = fx.files[&id]
.wpt
.iter()
.flat_map(|c| c.wpt.iter())
.collect();
let edited = wpts[0]; let edited = wpts[0];
assert_eq!(edited.id, ids[0]); assert_eq!(edited.id, ids[0]);
assert_eq!(edited.name.as_deref(), Some("new")); assert_eq!(edited.name.as_deref(), Some("new"));
assert_eq!(edited.desc.as_deref(), Some("new description")); assert_eq!(edited.desc.as_deref(), Some("new description"));
assert_eq!(edited.cmt.as_deref(), Some("new description")); assert_eq!(edited.cmt.as_deref(), Some("new description"));
assert_eq!(edited.sym.as_deref(), Some("Summit")); assert_eq!(edited.sym.as_deref(), Some("Summit"));
// an empty link removes the first one, the others are not the form's business // an empty link removes it
assert_eq!(edited.links.len(), 1); assert!(edited.link.is_none());
assert_eq!(edited.links[0].href, "https://second");
assert_eq!( assert_eq!(
(edited.coordinates.lng, edited.coordinates.lat, edited.ele), (edited.coordinates.lng, edited.coordinates.lat, edited.ele),
(4.5, 50.5, 12.0) (4.5, 50.5, 12.0)
@@ -106,57 +103,4 @@ mod tests {
// the other waypoint is as it was // the other waypoint is as it was
assert_eq!(wpts[1].name.as_deref(), Some("other")); assert_eq!(wpts[1].name.as_deref(), Some("other"));
} }
#[test]
fn test_the_link_of_the_form_is_the_first_one() {
let mut fx = Fixture::default();
let mut file = File::default();
file.wpt.push(WaypointChunk {
wpt: vec![Waypoint {
links: vec![
Link {
href: "https://first".into(),
text: Some("first".into()),
},
Link {
href: "https://second".into(),
text: None,
},
],
..Default::default()
}],
..Default::default()
});
let (id, wpt_id) = (file.id, waypoint_ids(&file).next().unwrap());
fx.files.insert(id, Rc::new(file));
let edit = |fx: &mut Fixture, link: &str| {
EditWaypoint {
file_id: id,
waypoint_id: wpt_id,
lng: 0.0,
lat: 0.0,
ele: 0.0,
name: "",
desc: "",
icon: "",
link,
}
.apply(&mut fx.state())
.unwrap();
fx.files[&id].wpt.iter().next().unwrap().links.clone()
};
// the same link keeps its text
let links = edit(&mut fx, "https://first");
assert_eq!(links.len(), 2);
assert_eq!(links[0].text.as_deref(), Some("first"));
// another one replaces the first, and the text that described the old one
let links = edit(&mut fx, "https://other");
assert_eq!(links.len(), 2);
assert_eq!(
(links[0].href.as_str(), links[0].text.clone()),
("https://other", None)
);
assert_eq!(links[1].href, "https://second");
}
} }
@@ -0,0 +1,13 @@
use crate::{Apply, CommandError, State};
#[derive(Debug)]
pub struct Elevation<'a> {
pub ele: &'a [f64],
}
impl Apply for Elevation<'_> {
fn apply(self, _state: &mut State) -> Result<(), CommandError> {
// TODO
Err(CommandError::NotImplemented("elevation"))
}
}
@@ -0,0 +1,11 @@
use crate::{Apply, CommandError, State};
#[derive(Debug)]
pub struct Extract;
impl Apply for Extract {
fn apply(self, _state: &mut State) -> Result<(), CommandError> {
// TODO
Err(CommandError::NotImplemented("extract"))
}
}
@@ -0,0 +1,19 @@
use crate::{Apply, CommandError, State};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MergeType {
Connect,
Group,
}
#[derive(Debug)]
pub struct Merge {
pub type_: MergeType,
}
impl Apply for Merge {
fn apply(self, _state: &mut State) -> Result<(), CommandError> {
// TODO
Err(CommandError::NotImplemented("merge"))
}
}
@@ -1,33 +1,25 @@
mod change_loop_start;
mod clean; mod clean;
mod crop; mod crop;
mod edit_waypoint; mod edit_waypoint;
mod elevation; mod elevation;
mod extract; mod extract;
mod insert_anchor;
mod merge; mod merge;
mod move_waypoint; mod move_waypoint;
mod new_waypoint; mod new_waypoint;
mod reduce;
mod reverse; mod reverse;
mod round_trip; mod splice_trackpoints;
mod route;
mod split; mod split;
mod time; mod time;
pub use change_loop_start::*;
pub use clean::*; pub use clean::*;
pub use crop::*; pub use crop::*;
pub use edit_waypoint::*; pub use edit_waypoint::*;
pub use elevation::*; pub use elevation::*;
pub use extract::*; pub use extract::*;
pub use insert_anchor::*;
pub use merge::*; pub use merge::*;
pub use move_waypoint::*; pub use move_waypoint::*;
pub use new_waypoint::*; pub use new_waypoint::*;
pub use reduce::*;
pub use reverse::*; pub use reverse::*;
pub use round_trip::*; pub use splice_trackpoints::*;
pub use route::*;
pub use split::*; pub use split::*;
pub use time::*; pub use time::*;
@@ -36,7 +36,7 @@ mod tests {
fn fixture() -> (Fixture, crate::FileId, Vec<crate::WaypointId>) { fn fixture() -> (Fixture, crate::FileId, Vec<crate::WaypointId>) {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
let mut file = File::default(); let mut file = File::default();
file.wpt.push(WaypointChunk { file.wpt.push(Rc::new(WaypointChunk {
wpt: (0..3) wpt: (0..3)
.map(|i| Waypoint { .map(|i| Waypoint {
name: Some(format!("w{i}")), name: Some(format!("w{i}")),
@@ -44,7 +44,7 @@ mod tests {
}) })
.collect(), .collect(),
..Default::default() ..Default::default()
}); }));
let id = file.id; let id = file.id;
let ids = waypoint_ids(&file).collect(); let ids = waypoint_ids(&file).collect();
fx.files.insert(id, Rc::new(file)); fx.files.insert(id, Rc::new(file));
@@ -55,7 +55,7 @@ mod tests {
#[test] #[test]
fn test_only_the_given_waypoint_moves_whatever_is_selected() { fn test_only_the_given_waypoint_moves_whatever_is_selected() {
let (mut fx, id, ids) = fixture(); let (mut fx, id, ids) = fixture();
let rev = fx.files[&id].wpt.rev_id; let rev = fx.files[&id].wpt_rev_id;
MoveWaypoint { MoveWaypoint {
file_id: id, file_id: id,
@@ -67,7 +67,11 @@ mod tests {
.apply(&mut fx.state()) .apply(&mut fx.state())
.unwrap(); .unwrap();
let wpts: Vec<_> = fx.files[&id].wpt.iter().collect(); let wpts: Vec<_> = fx.files[&id]
.wpt
.iter()
.flat_map(|c| c.wpt.iter())
.collect();
assert_eq!(wpts.len(), 3); assert_eq!(wpts.len(), 3);
assert_eq!( assert_eq!(
( (
@@ -83,7 +87,7 @@ mod tests {
assert_eq!((wpts[0].coordinates.lng, wpts[0].ele), (0.0, 0.0)); assert_eq!((wpts[0].coordinates.lng, wpts[0].ele), (0.0, 0.0));
assert_eq!((wpts[2].coordinates.lat, wpts[2].ele), (0.0, 0.0)); assert_eq!((wpts[2].coordinates.lat, wpts[2].ele), (0.0, 0.0));
// the coordinates changed, which is noticed by what is derived from them // the coordinates changed, which is noticed by what is derived from them
assert_ne!(fx.files[&id].wpt.rev_id, rev); assert_ne!(fx.files[&id].wpt_rev_id, rev);
assert_eq!(fx.selection, Selection::Empty); assert_eq!(fx.selection, Selection::Empty);
} }
@@ -1,6 +1,9 @@
use std::rc::Rc; use std::rc::Rc;
use crate::{Apply, CommandError, File, FileId, Link, LngLat, Selection, State, Waypoint}; use crate::{
Apply, CommandError, File, FileId, Link, LngLat, Selection, State, Waypoint,
insert_waypoints_at,
};
/// Adds a waypoint at the end of the waypoints of each selected file (or of the file of the /// Adds a waypoint at the end of the waypoints of each selected file (or of the file of the
/// selected elements). The strings are empty when the waypoint does not have the field. /// selected elements). The strings are empty when the waypoint does not have the field.
@@ -36,15 +39,7 @@ pub fn set_waypoint_fields(
// the description is also the comment, as it is what the other applications show // the description is also the comment, as it is what the other applications show
waypoint.cmt = non_empty(desc); waypoint.cmt = non_empty(desc);
waypoint.sym = non_empty(icon); waypoint.sym = non_empty(icon);
// the form has a single link: it is the first one, the others are left as they are waypoint.link = non_empty(link).map(|href| Link { href, text: None });
match (non_empty(link), waypoint.links.first_mut()) {
(Some(href), Some(first)) if first.href != href => *first = Link { href, text: None },
(Some(href), None) => waypoint.links.push(Link { href, text: None }),
(None, Some(_)) => {
waypoint.links.remove(0);
}
_ => (),
}
} }
impl Apply for NewWaypoint<'_> { impl Apply for NewWaypoint<'_> {
@@ -58,8 +53,7 @@ impl Apply for NewWaypoint<'_> {
.filter(|id| file_ids.contains(id)) .filter(|id| file_ids.contains(id))
.copied() .copied()
.collect(), .collect(),
Selection::Route { file_id, .. } Selection::Track { file_id, .. }
| Selection::Track { file_id, .. }
| Selection::TrackSegment { file_id, .. } | Selection::TrackSegment { file_id, .. }
| Selection::Waypoints { file_id } | Selection::Waypoints { file_id }
| Selection::Waypoint { file_id, .. } => vec![*file_id], | Selection::Waypoint { file_id, .. } => vec![*file_id],
@@ -83,7 +77,7 @@ impl Apply for NewWaypoint<'_> {
self.link, self.link,
); );
let file: &mut File = Rc::make_mut(state.files.get_mut(&id).unwrap()); let file: &mut File = Rc::make_mut(state.files.get_mut(&id).unwrap());
file.wpt.insert_at(usize::MAX, vec![waypoint]); insert_waypoints_at(file, usize::MAX, vec![waypoint]);
} }
Ok(()) Ok(())
} }
@@ -110,28 +104,20 @@ mod tests {
} }
fn waypoints(fx: &Fixture, id: FileId) -> Vec<Waypoint> { fn waypoints(fx: &Fixture, id: FileId) -> Vec<Waypoint> {
fx.files[&id].wpt.iter().cloned().collect() fx.files[&id]
.wpt
.iter()
.flat_map(|chunk| chunk.wpt.iter().cloned())
.collect()
} }
#[test] #[test]
fn test_new_waypoint_in_the_selected_file() { fn test_new_waypoint_in_the_selected_file() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
New { New { name: "a" }.apply(&mut fx.state()).unwrap();
name: "a", New { name: "b" }.apply(&mut fx.state()).unwrap();
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
New {
name: "b",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
let (a, b) = (fx.order.0[0], fx.order.0[1]); let (a, b) = (fx.order.0[0], fx.order.0[1]);
let rev = fx.files[&b].wpt.rev_id; let rev = fx.files[&b].wpt_rev_id;
// b is selected // b is selected
new_waypoint("peak").apply(&mut fx.state()).unwrap(); new_waypoint("peak").apply(&mut fx.state()).unwrap();
@@ -148,10 +134,10 @@ mod tests {
assert_eq!(wpt.cmt.as_deref(), Some("a description")); assert_eq!(wpt.cmt.as_deref(), Some("a description"));
assert_eq!(wpt.sym.as_deref(), Some("Summit")); assert_eq!(wpt.sym.as_deref(), Some("Summit"));
assert_eq!( assert_eq!(
wpt.links.first().map(|l| l.href.as_str()), wpt.link.as_ref().map(|l| l.href.as_str()),
Some("https://example.com") Some("https://example.com")
); );
assert_ne!(fx.files[&b].wpt.rev_id, rev); assert_ne!(fx.files[&b].wpt_rev_id, rev);
// added after the others // added after the others
let mut second = new_waypoint("second"); let mut second = new_waypoint("second");
@@ -169,13 +155,7 @@ mod tests {
#[test] #[test]
fn test_empty_fields_are_not_set() { fn test_empty_fields_are_not_set() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
New { New { name: "a" }.apply(&mut fx.state()).unwrap();
name: "a",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
let a = fx.order.0[0]; let a = fx.order.0[0];
NewWaypoint { NewWaypoint {
lng: 1.0, lng: 1.0,
@@ -190,20 +170,14 @@ mod tests {
.unwrap(); .unwrap();
let wpt = &waypoints(&fx, a)[0]; let wpt = &waypoints(&fx, a)[0];
assert!(wpt.name.is_none() && wpt.desc.is_none() && wpt.cmt.is_none()); assert!(wpt.name.is_none() && wpt.desc.is_none() && wpt.cmt.is_none());
assert!(wpt.sym.is_none() && wpt.links.is_empty()); assert!(wpt.sym.is_none() && wpt.link.is_none());
} }
#[test] #[test]
fn test_each_selected_file_gets_its_own_waypoint() { fn test_each_selected_file_gets_its_own_waypoint() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
for name in ["a", "b", "c"] { for name in ["a", "b", "c"] {
New { New { name }.apply(&mut fx.state()).unwrap();
name,
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
} }
let ids = fx.order.0.clone(); let ids = fx.order.0.clone();
fx.selection = Selection::File { fx.selection = Selection::File {
@@ -236,13 +210,7 @@ mod tests {
}, },
] { ] {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
New { New { name: "a" }.apply(&mut fx.state()).unwrap();
name: "a",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
let a = fx.order.0[0]; let a = fx.order.0[0];
fx.selection = selection(a); fx.selection = selection(a);
new_waypoint("w").apply(&mut fx.state()).unwrap(); new_waypoint("w").apply(&mut fx.state()).unwrap();
@@ -253,13 +221,7 @@ mod tests {
#[test] #[test]
fn test_nothing_selected_or_unknown_file() { fn test_nothing_selected_or_unknown_file() {
let mut fx = Fixture::default(); let mut fx = Fixture::default();
New { New { name: "a" }.apply(&mut fx.state()).unwrap();
name: "a",
trackpoint: None,
route: false,
}
.apply(&mut fx.state())
.unwrap();
fx.selection = Selection::Empty; fx.selection = Selection::Empty;
assert_eq!( assert_eq!(
new_waypoint("w").apply(&mut fx.state()), new_waypoint("w").apply(&mut fx.state()),
@@ -0,0 +1,11 @@
use crate::{Apply, CommandError, State};
#[derive(Debug)]
pub struct Reverse;
impl Apply for Reverse {
fn apply(self, _state: &mut State) -> Result<(), CommandError> {
// TODO
Err(CommandError::NotImplemented("reverse"))
}
}
@@ -0,0 +1,315 @@
use std::rc::Rc;
use crate::{Apply, CommandError, File, FileId, LngLat, Selection, State, Trackpoint};
/// Replaces the trackpoints `start..end` of the last track segment of the selection by the
/// given ones (a pure insertion when `start == end`, a pure removal when there are no new
/// points).
///
/// The selection can be made of several files, tracks or track segments: the indices are
/// meant for its very last segment, in file order, then track order, then segment order.
#[derive(Debug)]
pub struct SpliceTrackpoints<'a> {
pub start: u32,
pub end: u32,
pub lng: &'a [f64],
pub lat: &'a [f64],
pub ele: &'a [f64],
}
impl Apply for SpliceTrackpoints<'_> {
fn apply(self, state: &mut State) -> Result<(), CommandError> {
let (start, end) = (self.start as usize, self.end as usize);
if start > end || self.lng.len() != self.lat.len() || self.lat.len() != self.ele.len() {
return Err(CommandError::InvalidData(
"invalid trackpoints range".into(),
));
}
let (file_id, trk, seg) = last_segment(state).ok_or(CommandError::NothingToDo)?;
let mut file = (*state.files[&file_id]).clone();
let segment = &mut file.trk[trk].trkseg[seg];
if end > segment.len() {
return Err(CommandError::InvalidData(
"trackpoints range out of bounds".into(),
));
}
if start == end && self.lng.is_empty() {
return Err(CommandError::NothingToDo);
}
let points = (0..self.lng.len())
.map(|i| Trackpoint {
coordinates: LngLat {
lng: self.lng[i],
lat: self.lat[i],
},
ele: self.ele[i],
..Default::default()
})
.collect();
segment.splice(start, end, points);
segment.rev_id = Default::default();
state.files.insert(file_id, Rc::new(file));
Ok(())
}
}
/// Position (file, track index, segment index) of the last segment of the selection.
fn last_segment(state: &State) -> Option<(FileId, usize, usize)> {
let last_of_track = |file: &File, trk: usize| file.trk[trk].trkseg.len().checked_sub(1);
let last_of_file = |file: &File, filter: &dyn Fn(usize) -> bool| {
(0..file.trk.len())
.rev()
.filter(|&trk| filter(trk))
.find_map(|trk| last_of_track(file, trk).map(|seg| (trk, seg)))
};
match &*state.selection {
Selection::File { file_ids } => state
.order
.0
.iter()
.rev()
.filter(|id| file_ids.contains(id))
.find_map(|id| {
let (trk, seg) = last_of_file(state.files.get(id)?, &|_| true)?;
Some((*id, trk, seg))
}),
Selection::Track { file_id, trk_ids } => {
let file = state.files.get(file_id)?;
let (trk, seg) = last_of_file(file, &|trk| trk_ids.contains(&file.trk[trk].id))?;
Some((*file_id, trk, seg))
}
Selection::TrackSegment {
file_id,
trk_id,
trkseg_ids,
} => {
let file = state.files.get(file_id)?;
let trk = file.trk.iter().position(|trk| trk.id == *trk_id)?;
let seg = file.trk[trk]
.trkseg
.iter()
.rposition(|seg| trkseg_ids.contains(&seg.id))?;
Some((*file_id, trk, seg))
}
Selection::Empty | Selection::Waypoints { .. } | Selection::Waypoint { .. } => None,
}
}
#[cfg(test)]
mod tests {
use std::collections::HashSet;
use crate::{FileId, Load, engine::command::fixture::Fixture};
use super::*;
fn loaded() -> (Fixture, FileId) {
let mut fx = Fixture::default();
let data = std::fs::read("data/with_tracks_and_segments.gpx").unwrap();
Load {
data: &data,
name: "file",
}
.apply(&mut fx.state())
.unwrap();
let id = fx.order.0[0];
let trk = &fx.files[&id].trk[0];
fx.selection = Selection::TrackSegment {
file_id: id,
trk_id: trk.id,
trkseg_ids: HashSet::from([trk.trkseg[0].id]),
};
(fx, id)
}
fn splice<'a>(
start: u32,
end: u32,
lng: &'a [f64],
lat: &'a [f64],
ele: &'a [f64],
) -> SpliceTrackpoints<'a> {
SpliceTrackpoints {
start,
end,
lng,
lat,
ele,
}
}
#[test]
fn test_splice_replaces_points_of_selected_segment_only() {
let (mut fx, id) = loaded();
let before = fx.files[&id].clone();
let len = before.trk[0].trkseg[0].len();
assert!(len >= 3);
splice(1, 3, &[1.0, 2.0, 3.0], &[4.0, 5.0, 6.0], &[7.0, 8.0, 9.0])
.apply(&mut fx.state())
.unwrap();
let after = &fx.files[&id];
let (old, new) = (&before.trk[0].trkseg[0], &after.trk[0].trkseg[0]);
assert_eq!(new.len(), len + 1);
assert_eq!(new[0].coordinates.lng, old[0].coordinates.lng);
assert_eq!(new[1].coordinates.lng, 1.0);
assert_eq!(new[3].coordinates.lat, 6.0);
assert_eq!(new[3].ele, 9.0);
assert_eq!(new[4].coordinates.lng, old[3].coordinates.lng);
assert_ne!(new.rev_id, old.rev_id);
assert_eq!(new.id, old.id);
// other segments and tracks keep their revision
for (b, a) in before.trk.iter().zip(&after.trk) {
for (b, a) in b.trkseg.iter().zip(&a.trkseg) {
if a.id != new.id {
assert_eq!(a.rev_id, b.rev_id);
}
}
}
}
#[test]
fn test_splice_append_and_remove() {
let (mut fx, id) = loaded();
let len = fx.files[&id].trk[0].trkseg[0].len() as u32;
splice(len, len, &[1.0], &[2.0], &[3.0])
.apply(&mut fx.state())
.unwrap();
let seg = &fx.files[&id].trk[0].trkseg[0];
assert_eq!(seg.len(), len as usize + 1);
assert_eq!(seg[len as usize].ele, 3.0);
splice(0, len + 1, &[], &[], &[])
.apply(&mut fx.state())
.unwrap();
assert_eq!(fx.files[&id].trk[0].trkseg[0].len(), 0);
}
#[test]
fn test_splice_invalid_arguments_change_nothing() {
let (mut fx, id) = loaded();
let before = fx.files[&id].clone();
let len = before.trk[0].trkseg[0].len() as u32;
let results = [
splice(2, 1, &[], &[], &[]).apply(&mut fx.state()),
splice(0, 0, &[1.0], &[], &[]).apply(&mut fx.state()),
splice(0, len + 1, &[], &[], &[]).apply(&mut fx.state()),
];
assert!(
results
.iter()
.all(|r| matches!(r, Err(CommandError::InvalidData(_))))
);
assert_eq!(
splice(0, 0, &[], &[], &[]).apply(&mut fx.state()),
Err(CommandError::NothingToDo)
);
assert!(std::rc::Rc::ptr_eq(&fx.files[&id], &before));
}
#[test]
fn test_splice_needs_a_segment_selection() {
let (mut fx, _) = loaded();
fx.selection = Selection::Empty;
assert_eq!(
splice(0, 0, &[1.0], &[1.0], &[1.0]).apply(&mut fx.state()),
Err(CommandError::NothingToDo)
);
}
#[test]
fn test_splice_targets_last_segment_of_the_selection() {
let (mut fx, id) = loaded();
let file = fx.files[&id].clone();
assert!(file.trk.len() >= 2);
let last_trk = file.trk.len() - 1;
let last_seg = file.trk[last_trk].trkseg.len() - 1;
// whole file selected: last segment of its last track
fx.selection = Selection::File {
file_ids: HashSet::from([id]),
};
splice(0, 0, &[1.0], &[2.0], &[3.0])
.apply(&mut fx.state())
.unwrap();
let after = &fx.files[&id];
for (t, (b, a)) in file.trk.iter().zip(&after.trk).enumerate() {
for (s, (b, a)) in b.trkseg.iter().zip(&a.trkseg).enumerate() {
let target = (t, s) == (last_trk, last_seg);
assert_eq!(a.len(), b.len() + usize::from(target));
assert_eq!(a.rev_id != b.rev_id, target);
}
}
// several tracks selected: last selected one (in file order, whatever the set order)
let ids: Vec<_> = file.trk.iter().map(|t| t.id).collect();
fx.selection = Selection::Track {
file_id: id,
trk_ids: HashSet::from([ids[1], ids[0]]),
};
let len = |fx: &Fixture, t: usize| {
let trk = &fx.files[&id].trk[t];
trk.trkseg.last().unwrap().len()
};
let (l0, l1) = (len(&fx, 0), len(&fx, 1));
splice(0, 0, &[1.0], &[2.0], &[3.0])
.apply(&mut fx.state())
.unwrap();
assert_eq!(len(&fx, 0), l0);
assert_eq!(len(&fx, 1), l1 + 1);
// several segments selected
let trk = &fx.files[&id].trk[0];
let seg_ids: Vec<_> = trk.trkseg.iter().map(|s| s.id).collect();
if seg_ids.len() >= 2 {
fx.selection = Selection::TrackSegment {
file_id: id,
trk_id: trk.id,
trkseg_ids: seg_ids.iter().copied().collect(),
};
let lens: Vec<_> = trk.trkseg.iter().map(|s| s.len()).collect();
splice(0, 0, &[1.0], &[2.0], &[3.0])
.apply(&mut fx.state())
.unwrap();
let after: Vec<_> = fx.files[&id].trk[0]
.trkseg
.iter()
.map(|s| s.len())
.collect();
let n = lens.len();
assert_eq!(after[..n - 1], lens[..n - 1]);
assert_eq!(after[n - 1], lens[n - 1] + 1);
}
}
#[test]
fn test_splice_on_multiple_files_uses_last_in_file_order() {
let (mut fx, first) = loaded();
let data = std::fs::read("data/with_tracks_and_segments.gpx").unwrap();
Load {
data: &data,
name: "file",
}
.apply(&mut fx.state())
.unwrap();
let second = fx.order.0[1];
fx.selection = Selection::File {
file_ids: HashSet::from([second, first]),
};
let total = |fx: &Fixture, id: FileId| -> usize {
fx.files[&id]
.trk
.iter()
.flat_map(|t| &t.trkseg)
.map(|s| s.len())
.sum()
};
let (a, b) = (total(&fx, first), total(&fx, second));
splice(0, 0, &[1.0], &[2.0], &[3.0])
.apply(&mut fx.state())
.unwrap();
assert_eq!(total(&fx, first), a);
assert_eq!(total(&fx, second), b + 1);
}
}
@@ -0,0 +1,13 @@
use crate::{Apply, CommandError, State};
#[derive(Debug)]
pub struct Split {
pub at: u32,
}
impl Apply for Split {
fn apply(self, _state: &mut State) -> Result<(), CommandError> {
// TODO
Err(CommandError::NotImplemented("split"))
}
}
@@ -0,0 +1,11 @@
use crate::{Apply, CommandError, State};
#[derive(Debug)]
pub struct Time;
impl Apply for Time {
fn apply(self, _state: &mut State) -> Result<(), CommandError> {
// TODO
Err(CommandError::NotImplemented("time"))
}
}
@@ -1,9 +1,11 @@
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use crate::{FileId, FileWaypointsRevisionId, Files, TrackSegmentId, TrackSegmentRevisionId}; use crate::{
FileId, FileWaypointsRevisionId, StackEntry as Files, TrackSegmentId, TrackSegmentRevisionId,
};
/// Coordinates buffers, as flat `[lng, lat, lng, lat, ...]` arrays so that they can be handed /// Coordinates buffers, as flat `[lng, lat, lng, lat, ...]` arrays so that they can be handed
/// to the UI without per-point calls: one per segment of a route or track (its trackpoints) and one per file /// to the UI without per-point calls: one per track segment (its trackpoints) and one per file
/// (its waypoints). A buffer is only rebuilt when the revision of its segment (or the waypoints /// (its waypoints). A buffer is only rebuilt when the revision of its segment (or the waypoints
/// of its file) changes, so editing a segment does not touch the buffers of the others. /// of its file) changes, so editing a segment does not touch the buffers of the others.
#[derive(Debug, Default)] #[derive(Debug, Default)]
@@ -21,16 +23,16 @@ impl CoordinatesCache {
if self if self
.waypoints .waypoints
.get(&file.id) .get(&file.id)
.is_none_or(|(r, _)| *r != file.wpt.rev_id) .is_none_or(|(r, _)| *r != file.wpt_rev_id)
{ {
let mut coordinates = Vec::new(); let mut coordinates = Vec::new();
for wpt in file.wpt.iter() { for wpt in file.wpt.iter().flat_map(|chunk| &chunk.wpt) {
coordinates.extend([wpt.coordinates.lng, wpt.coordinates.lat]); coordinates.extend([wpt.coordinates.lng, wpt.coordinates.lat]);
} }
self.waypoints self.waypoints
.insert(file.id, (file.wpt.rev_id, coordinates)); .insert(file.id, (file.wpt_rev_id, coordinates));
} }
for seg in file.segments() { for seg in file.trk.iter().flat_map(|trk| &trk.trkseg) {
segments.insert(seg.id); segments.insert(seg.id);
if self if self
.segments .segments
@@ -136,16 +138,17 @@ mod tests {
..Default::default() ..Default::default()
}; };
let mut file = (*fx.files[&id]).clone(); let mut file = (*fx.files[&id]).clone();
file.wpt = crate::Waypoints::new([ file.wpt_rev_id = Default::default();
WaypointChunk { file.wpt = vec![
Rc::new(WaypointChunk {
wpt: vec![wpt(1.0, 2.0)], wpt: vec![wpt(1.0, 2.0)],
..Default::default() ..Default::default()
}, }),
WaypointChunk { Rc::new(WaypointChunk {
wpt: vec![wpt(3.0, 4.0)], wpt: vec![wpt(3.0, 4.0)],
..Default::default() ..Default::default()
}, }),
]); ];
fx.files.insert(id, Rc::new(file)); fx.files.insert(id, Rc::new(file));
let mut cache = CoordinatesCache::default(); let mut cache = CoordinatesCache::default();
cache.update(Some(&fx.files)); cache.update(Some(&fx.files));
@@ -1,10 +1,9 @@
use crate::{ use crate::{
File, FileId, FileWaypointsRevisionId, RouteId, TrackId, TrackInfo, TrackSegment, File, FileId, FileWaypointsRevisionId, TrackId, TrackSegmentId, TrackSegmentRevisionId,
TrackSegmentId, TrackSegmentRevisionId, WaypointId, WaypointId,
}; };
/// What the UI needs to display a file: its name and the structure of its routes, tracks and /// What the UI needs to display a file: its name and the structure of its tracks and waypoints,
/// waypoints,
/// with the ids that reference every element. Coordinates are not part of it, they are read /// with the ids that reference every element. Coordinates are not part of it, they are read
/// from the buffers of the [`CoordinatesCache`](crate::CoordinatesCache) (the `i`-th waypoint /// from the buffers of the [`CoordinatesCache`](crate::CoordinatesCache) (the `i`-th waypoint
/// of a file is the `i`-th coordinates pair of its waypoint buffer, same for the trackpoints of /// of a file is the `i`-th coordinates pair of its waypoint buffer, same for the trackpoints of
@@ -14,47 +13,21 @@ pub struct FileStructure {
pub id: FileId, pub id: FileId,
pub name: String, pub name: String,
pub desc: Option<String>, pub desc: Option<String>,
pub routes: Vec<RouteNode>,
pub tracks: Vec<TrackNode>, pub tracks: Vec<TrackNode>,
pub waypoints: Vec<WaypointNode>, pub waypoints: Vec<WaypointNode>,
/// Changes whenever the waypoints of the file (hence their buffer) change. /// Changes whenever the waypoints of the file (hence their buffer) change.
pub wpt_rev_id: FileWaypointsRevisionId, pub wpt_rev_id: FileWaypointsRevisionId,
} }
/// The name, description and style of a route or a track (the style only when the file defines
/// it).
#[derive(Debug, Clone, PartialEq)]
pub struct PathInfo {
pub name: Option<String>,
pub desc: Option<String>,
pub color: Option<String>,
pub opacity: Option<f64>,
pub width: Option<f64>,
}
impl From<&TrackInfo> for PathInfo {
fn from(info: &TrackInfo) -> Self {
Self {
name: info.name.clone(),
desc: info.desc.clone(),
color: info.color.clone(),
opacity: info.opacity,
width: info.width,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct RouteNode {
pub id: RouteId,
pub info: PathInfo,
pub segment: SegmentNode,
}
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub struct TrackNode { pub struct TrackNode {
pub id: TrackId, pub id: TrackId,
pub info: PathInfo, pub name: Option<String>,
pub desc: Option<String>,
/// Style of the track, only when the file defines it.
pub color: Option<String>,
pub opacity: Option<f64>,
pub width: Option<f64>,
pub segments: Vec<SegmentNode>, pub segments: Vec<SegmentNode>,
} }
@@ -73,56 +46,51 @@ pub struct WaypointNode {
pub sym: Option<String>, pub sym: Option<String>,
} }
impl From<&TrackSegment> for SegmentNode {
fn from(seg: &TrackSegment) -> Self {
Self {
id: seg.id,
rev_id: seg.rev_id,
len: seg.len(),
}
}
}
impl FileStructure { impl FileStructure {
pub fn new(file: &File) -> Self { pub fn new(file: &File) -> Self {
Self { Self {
id: file.id, id: file.id,
name: file.info.name.clone(), name: file.info.name.clone(),
desc: file.info.desc.clone(), desc: file.info.desc.clone(),
routes: file
.rte
.iter()
.map(|rte| RouteNode {
id: rte.id,
info: (&rte.info).into(),
segment: (&rte.seg).into(),
})
.collect(),
tracks: file tracks: file
.trk .trk
.iter() .iter()
.map(|trk| TrackNode { .map(|trk| TrackNode {
id: trk.id, id: trk.id,
info: (&trk.info).into(), name: trk.info.name.clone(),
segments: trk.trkseg.iter().map(Into::into).collect(), desc: trk.info.desc.clone(),
color: trk.info.color.clone(),
opacity: trk.info.opacity,
width: trk.info.width,
segments: trk
.trkseg
.iter()
.map(|seg| SegmentNode {
id: seg.id,
rev_id: seg.rev_id,
len: seg.len(),
})
.collect(),
}) })
.collect(), .collect(),
waypoints: file waypoints: file
.wpt .wpt
.iter() .iter()
.flat_map(|chunk| &chunk.wpt)
.map(|wpt| WaypointNode { .map(|wpt| WaypointNode {
id: wpt.id, id: wpt.id,
name: wpt.name.clone(), name: wpt.name.clone(),
sym: wpt.sym.clone(), sym: wpt.sym.clone(),
}) })
.collect(), .collect(),
wpt_rev_id: file.wpt.rev_id, wpt_rev_id: file.wpt_rev_id,
} }
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::rc::Rc;
use crate::{Apply, Load, Waypoint, WaypointChunk, engine::command::fixture::Fixture}; use crate::{Apply, Load, Waypoint, WaypointChunk, engine::command::fixture::Fixture};
@@ -146,8 +114,11 @@ mod tests {
); );
assert_eq!(node.tracks.len(), file.trk.len()); assert_eq!(node.tracks.len(), file.trk.len());
for (n, t) in node.tracks.iter().zip(&file.trk) { for (n, t) in node.tracks.iter().zip(&file.trk) {
assert_eq!(n.id, t.id); assert_eq!((n.id, &n.name, &n.desc), (t.id, &t.info.name, &t.info.desc));
assert_eq!(n.info, PathInfo::from(&t.info)); assert_eq!(
(&n.color, n.opacity, n.width),
(&t.info.color, t.info.opacity, t.info.width)
);
assert_eq!(n.segments.len(), t.trkseg.len()); assert_eq!(n.segments.len(), t.trkseg.len());
for (n, s) in n.segments.iter().zip(&t.trkseg) { for (n, s) in n.segments.iter().zip(&t.trkseg) {
assert_eq!((n.id, n.rev_id, n.len), (s.id, s.rev_id, s.len())); assert_eq!((n.id, n.rev_id, n.len), (s.id, s.rev_id, s.len()));
@@ -162,17 +133,18 @@ mod tests {
name: Some(n.to_string()), name: Some(n.to_string()),
..Default::default() ..Default::default()
}; };
let before = file.wpt.rev_id; let before = file.wpt_rev_id;
file.wpt = crate::Waypoints::new([ file.wpt_rev_id = Default::default();
WaypointChunk { file.wpt = vec![
Rc::new(WaypointChunk {
wpt: vec![wpt("a"), wpt("b")], wpt: vec![wpt("a"), wpt("b")],
..Default::default() ..Default::default()
}, }),
WaypointChunk { Rc::new(WaypointChunk {
wpt: vec![wpt("c")], wpt: vec![wpt("c")],
..Default::default() ..Default::default()
}, }),
]); ];
let node = FileStructure::new(&file); let node = FileStructure::new(&file);
let names: Vec<_> = node let names: Vec<_> = node
.waypoints .waypoints
@@ -181,6 +153,6 @@ mod tests {
.collect(); .collect();
assert_eq!(names, ["a", "b", "c"]); assert_eq!(names, ["a", "b", "c"]);
assert_ne!(node.wpt_rev_id, before); assert_ne!(node.wpt_rev_id, before);
assert_eq!(node.wpt_rev_id, file.wpt.rev_id); assert_eq!(node.wpt_rev_id, file.wpt_rev_id);
} }
} }
@@ -1,6 +1,6 @@
use std::collections::HashMap; use std::collections::HashMap;
use crate::{Diff, FileId, FileStructure, Files}; use crate::{Diff, FileId, FileStructure, StackEntry as Files};
/// The structure of each file, only recomputed for the files that changed according to the /// The structure of each file, only recomputed for the files that changed according to the
/// [`Diff`] of the stack. /// [`Diff`] of the stack.
@@ -1,13 +1,11 @@
mod coordinates_cache; mod coordinates_cache;
mod file_structure; mod file_structure;
mod file_structure_cache; mod file_structure_cache;
mod routing_buffer;
mod statistics_buffer; mod statistics_buffer;
mod statistics_cache; mod statistics_cache;
pub use coordinates_cache::*; pub use coordinates_cache::*;
pub use file_structure::*; pub use file_structure::*;
pub use file_structure_cache::*; pub use file_structure_cache::*;
pub use routing_buffer::*;
pub use statistics_buffer::*; pub use statistics_buffer::*;
pub use statistics_cache::*; pub use statistics_cache::*;
@@ -0,0 +1,482 @@
use crate::{GlobalStatistics, Statistics, TrackSegment, sum_options};
/// Value of the timestamps of the trackpoints that have none.
pub const NO_TIME: i64 = i64::MIN;
/// Flattened statistics of the selected segments, one entry per trackpoint, in selection order.
///
/// The distance, time, moving and elevation values are cumulative over the whole selection (the
/// second segment continues where the first one ended), so the statistics of any range of
/// trackpoints are the difference between its two ends: see [`StatisticsBuffer::slice`].
/// Times are in milliseconds, distances in kilometers, speeds in km/h. Missing times are
/// [`NO_TIME`], missing measures are NaN.
#[derive(Debug, Default)]
pub struct StatisticsBuffer {
/// Statistics of the whole selection.
pub global: GlobalStatistics,
pub total_distance: Vec<f64>,
pub moving_distance: Vec<f64>,
pub total_time: Vec<i64>,
pub moving_time: Vec<i64>,
pub speed: Vec<f64>,
pub elevation_gain: Vec<f64>,
pub elevation_loss: Vec<f64>,
pub slope: Vec<f64>,
pub slope_segment_slope: Vec<f64>,
pub slope_segment_distance: Vec<f64>,
pub lng: Vec<f64>,
pub lat: Vec<f64>,
pub ele: Vec<f64>,
/// Timestamps, in milliseconds since the epoch.
pub time: Vec<i64>,
pub hr: Vec<f64>,
pub cad: Vec<f64>,
pub atemp: Vec<f64>,
pub power: Vec<f64>,
/// Surface of the trackpoints: 0 when unknown, else 1 + its code in the categories of the
/// engine (so that it is never 0 for a known surface).
pub surface: Vec<u8>,
/// Highway of the trackpoints, as the surface.
pub highway: Vec<u8>,
/// SAC hiking scale of the trackpoints, as the surface.
pub sac_scale: Vec<u8>,
/// Mountain biking scale of the trackpoints, as the surface.
pub mtb_scale: Vec<u8>,
}
/// 0 for an unknown value, else the code plus one. The categories hold at most 255 values, so it
/// fits.
fn unknown_or_next(code: Option<u8>) -> u8 {
code.and_then(|code| code.checked_add(1)).unwrap_or(0)
}
impl StatisticsBuffer {
pub fn len(&self) -> usize {
self.total_distance.len()
}
pub fn is_empty(&self) -> bool {
self.total_distance.is_empty()
}
/// `selected`: the segments and their statistics, in order.
pub fn update(&mut self, selected: &[(&TrackSegment, &Statistics)]) {
self.global = GlobalStatistics::default();
self.total_distance.clear();
self.moving_distance.clear();
self.total_time.clear();
self.moving_time.clear();
self.speed.clear();
self.elevation_gain.clear();
self.elevation_loss.clear();
self.slope.clear();
self.slope_segment_slope.clear();
self.slope_segment_distance.clear();
self.lng.clear();
self.lat.clear();
self.ele.clear();
self.time.clear();
self.hr.clear();
self.cad.clear();
self.atemp.clear();
self.power.clear();
self.surface.clear();
self.highway.clear();
self.sac_scale.clear();
self.mtb_scale.clear();
let optional = |value: Option<f64>| value.unwrap_or(f64::NAN);
for (segment, stats) in selected {
for (trkpt, trkpt_stats) in segment.iter().zip(stats.local.iter()) {
let cumul_stats = &self.global;
self.total_distance
.push(cumul_stats.total_distance + trkpt_stats.total_distance);
self.moving_distance.push(
sum_options(cumul_stats.moving_distance, trkpt_stats.moving_distance)
.unwrap_or_default(),
);
self.total_time.push(
sum_options(cumul_stats.total_time, trkpt_stats.total_time).unwrap_or_default(),
);
self.moving_time.push(
sum_options(cumul_stats.moving_time, trkpt_stats.moving_time)
.unwrap_or_default(),
);
self.speed.push(trkpt_stats.speed.unwrap_or_default());
self.elevation_gain
.push(cumul_stats.elevation_gain + trkpt_stats.elevation_gain);
self.elevation_loss
.push(cumul_stats.elevation_loss + trkpt_stats.elevation_loss);
self.slope.push(trkpt_stats.slope);
self.slope_segment_slope
.push(trkpt_stats.slope_segment.slope);
self.slope_segment_distance
.push(trkpt_stats.slope_segment.distance);
self.lng.push(trkpt.coordinates.lng);
self.lat.push(trkpt.coordinates.lat);
self.ele.push(trkpt.ele);
self.time.push(trkpt.time.unwrap_or(NO_TIME));
self.hr.push(optional(trkpt.hr.map(f64::from)));
self.cad.push(optional(trkpt.cad.map(f64::from)));
self.atemp.push(optional(trkpt.atemp.map(f64::from)));
self.power.push(optional(trkpt.power.map(f64::from)));
self.surface.push(unknown_or_next(trkpt.surface));
self.highway.push(unknown_or_next(trkpt.highway));
self.sac_scale.push(unknown_or_next(trkpt.sac_scale));
self.mtb_scale.push(unknown_or_next(trkpt.mtb_scale));
}
self.global.merge(&stats.global);
}
}
/// Statistics of the trackpoints from `start` to `end` (both included) of the selection, for
/// example the part of an elevation profile the user dragged over. `None` if the range is
/// not inside the selection.
///
/// It is done in constant time, from the cumulative values at both ends: the bounds and
/// the averages are the ones of the whole selection, they are not computed for the range.
pub fn slice(&self, start: usize, end: usize) -> Option<GlobalStatistics> {
if start > end || end >= self.len() {
return None;
}
let delta = |values: &[f64]| values[end] - values[start];
let delta_time = |values: &[i64]| values[end] - values[start];
let time = |i: usize| (self.time[i] != NO_TIME).then_some(self.time[i]);
Some(GlobalStatistics {
total_distance: delta(&self.total_distance),
moving_distance: self
.global
.moving_distance
.map(|_| delta(&self.moving_distance)),
total_time: self.global.total_time.map(|_| delta_time(&self.total_time)),
moving_time: self
.global
.moving_time
.map(|_| delta_time(&self.moving_time)),
elevation_gain: delta(&self.elevation_gain),
elevation_loss: delta(&self.elevation_loss),
start_time: time(start),
end_time: time(end),
bounds: self.global.bounds,
hr: self.global.hr,
cad: self.global.cad,
atemp: self.global.atemp,
power: self.global.power,
})
}
}
#[cfg(test)]
mod tests {
use crate::parse;
use super::*;
fn computed(path: &str) -> (TrackSegment, Statistics) {
let data = std::fs::read(path).unwrap();
let file = parse(&data, &mut Default::default()).unwrap();
let segment = file.trk[0].trkseg[0].clone();
let stats = Statistics::compute(&segment);
(segment, stats)
}
fn all_lengths(buffer: &StatisticsBuffer) -> Vec<usize> {
vec![
buffer.total_distance.len(),
buffer.moving_distance.len(),
buffer.total_time.len(),
buffer.moving_time.len(),
buffer.speed.len(),
buffer.elevation_gain.len(),
buffer.elevation_loss.len(),
buffer.slope.len(),
buffer.slope_segment_slope.len(),
buffer.slope_segment_distance.len(),
buffer.lng.len(),
buffer.lat.len(),
buffer.ele.len(),
buffer.time.len(),
buffer.hr.len(),
buffer.cad.len(),
buffer.atemp.len(),
buffer.power.len(),
buffer.surface.len(),
buffer.highway.len(),
buffer.sac_scale.len(),
buffer.mtb_scale.len(),
]
}
#[test]
fn test_empty() {
let mut buffer = StatisticsBuffer::default();
buffer.update(&[]);
assert!(buffer.is_empty());
assert!(buffer.speed.is_empty());
assert_eq!(buffer.global.total_distance, 0.0);
assert!(buffer.slice(0, 0).is_none());
}
#[test]
fn test_single_segment_matches_local_stats() {
let (segment, s) = computed("data/simple.gpx");
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
let n = s.local.len();
assert!(all_lengths(&buffer).iter().all(|len| *len == n));
assert_eq!(buffer.len(), n);
for (i, local) in s.local.iter().enumerate() {
assert_eq!(buffer.total_distance[i], local.total_distance);
assert_eq!(buffer.slope[i], local.slope);
}
// the trackpoints
for (i, trkpt) in segment.iter().enumerate() {
assert_eq!(buffer.lng[i], trkpt.coordinates.lng);
assert_eq!(buffer.lat[i], trkpt.coordinates.lat);
assert_eq!(buffer.ele[i], trkpt.ele);
}
}
#[test]
fn test_global_is_the_merge_of_the_segments() {
let (segment, s) = computed("data/simple.gpx");
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s), (&segment, &s)]);
let global = &buffer.global;
assert!((global.total_distance - 2.0 * s.global.total_distance).abs() < 1e-9);
assert!((global.elevation_gain - 2.0 * s.global.elevation_gain).abs() < 1e-9);
assert!((global.elevation_loss - 2.0 * s.global.elevation_loss).abs() < 1e-9);
// and it is the last cumulative value of the points
assert_eq!(
global.total_distance,
*buffer.total_distance.last().unwrap()
);
buffer.update(&[(&segment, &s)]);
assert_eq!(buffer.global.total_distance, s.global.total_distance);
buffer.update(&[]);
assert_eq!(buffer.global.total_distance, 0.0);
}
#[test]
fn test_distances_accumulate_over_segments() {
let (segment, s) = computed("data/simple.gpx");
let n = s.local.len();
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s), (&segment, &s)]);
assert_eq!(buffer.total_distance.len(), 2 * n);
// the second segment starts where the first one ended
assert_eq!(buffer.total_distance[n], s.global.total_distance);
assert!((buffer.total_distance[2 * n - 1] - 2.0 * s.global.total_distance).abs() < 1e-9);
assert!(buffer.total_distance.windows(2).all(|w| w[0] <= w[1]));
assert!((buffer.elevation_gain[2 * n - 1] - 2.0 * s.global.elevation_gain).abs() < 1e-9);
}
#[test]
fn test_total_time_accumulates_over_segments() {
let (segment, s) = computed("data/with_time.gpx");
let n = s.local.len();
let duration = s.global.total_time.unwrap();
assert!(duration > 0);
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s), (&segment, &s)]);
assert_eq!(buffer.total_time[n - 1], duration);
assert_eq!(buffer.total_time[n], duration);
assert_eq!(buffer.total_time[2 * n - 1], 2 * duration);
assert!(buffer.total_time.windows(2).all(|w| w[0] <= w[1]));
assert!(buffer.time.iter().all(|t| *t != NO_TIME));
}
#[test]
fn test_missing_times_and_measures_are_nan() {
let (segment, s) = computed("data/simple.gpx");
assert!(segment.iter().all(|trkpt| trkpt.time.is_none()));
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
assert!(buffer.time.iter().all(|t| *t == NO_TIME));
assert!(buffer.hr.iter().all(|v| v.is_nan()));
assert_eq!(buffer.global.hr.count, 0);
assert_eq!(buffer.global.total_time, None);
}
#[test]
fn test_surface_and_highway_codes() {
let (segment, s) = computed("data/with_highway.gpx");
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
// 0 for the trackpoints that have none, else the code of the engine plus one
assert_eq!(buffer.surface, [1, 1, 0, 2, 2]);
assert_eq!(buffer.highway, [1, 1, 0, 2, 0]);
assert_eq!(buffer.sac_scale, [0, 0, 0, 1, 2]);
assert_eq!(buffer.mtb_scale, [0, 0, 0, 1, 1]);
assert!(all_lengths(&buffer).iter().all(|len| *len == 5));
}
#[test]
fn test_codes_of_the_trackpoints_are_used_as_they_are() {
let (mut segment, _) = computed("data/simple.gpx");
let mut point = segment[0].clone();
point.surface = Some(7);
point.highway = Some(254);
point.sac_scale = Some(0);
point.mtb_scale = Some(3);
segment.splice(0, 1, vec![point]);
let s = Statistics::compute(&segment);
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
assert_eq!((buffer.surface[0], buffer.highway[0]), (8, 255));
assert_eq!((buffer.sac_scale[0], buffer.mtb_scale[0]), (1, 4));
assert_eq!((buffer.surface[1], buffer.highway[1]), (0, 0));
assert_eq!((buffer.sac_scale[1], buffer.mtb_scale[1]), (0, 0));
}
#[test]
fn test_no_codes_without_surface_and_highway() {
let (segment, s) = computed("data/simple.gpx");
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
assert_eq!(buffer.surface.len(), s.local.len());
assert!(buffer.surface.iter().all(|c| *c == 0));
assert!(buffer.highway.iter().all(|c| *c == 0));
assert!(buffer.sac_scale.iter().all(|c| *c == 0));
assert!(buffer.mtb_scale.iter().all(|c| *c == 0));
// and they are reset by the next update
buffer.update(&[]);
assert!(buffer.surface.is_empty() && buffer.highway.is_empty());
assert!(buffer.sac_scale.is_empty() && buffer.mtb_scale.is_empty());
}
#[test]
fn test_update_replaces_previous_content() {
let (segment, s) = computed("data/simple.gpx");
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
buffer.update(&[(&segment, &s)]);
assert_eq!(buffer.total_distance.len(), s.local.len());
assert!(all_lengths(&buffer).iter().all(|len| *len == s.local.len()));
buffer.update(&[]);
assert!(buffer.total_distance.is_empty());
assert!(all_lengths(&buffer).iter().all(|len| *len == 0));
}
#[test]
fn test_slice_of_the_whole_selection_is_the_global_statistics() {
let (segment, s) = computed("data/with_time.gpx");
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s), (&segment, &s)]);
let slice = buffer.slice(0, buffer.len() - 1).unwrap();
let global = &buffer.global;
assert!((slice.total_distance - global.total_distance).abs() < 1e-9);
assert!((slice.elevation_gain - global.elevation_gain).abs() < 1e-9);
assert!((slice.elevation_loss - global.elevation_loss).abs() < 1e-9);
assert_eq!(slice.total_time, global.total_time);
assert_eq!(slice.moving_time, global.moving_time);
assert_eq!(slice.start_time, global.start_time);
assert_eq!(slice.end_time, global.end_time);
}
#[test]
fn test_slice_of_a_range() {
let (segment, s) = computed("data/with_time.gpx");
let n = s.local.len();
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
let (start, end) = (n / 4, n / 2);
let slice = buffer.slice(start, end).unwrap();
assert!(
(slice.total_distance - (buffer.total_distance[end] - buffer.total_distance[start]))
.abs()
< 1e-12
);
assert_eq!(
slice.total_time,
Some(buffer.total_time[end] - buffer.total_time[start])
);
assert_eq!(
slice.moving_time,
Some(buffer.moving_time[end] - buffer.moving_time[start])
);
assert_eq!(slice.start_time, Some(buffer.time[start]));
assert_eq!(slice.end_time, Some(buffer.time[end]));
assert!(slice.total_distance < buffer.global.total_distance);
assert!(slice.total_speed().is_some());
// a single point has nothing between its ends
let point = buffer.slice(start, start).unwrap();
assert_eq!(point.total_distance, 0.0);
assert_eq!(point.total_time, Some(0));
}
#[test]
fn test_slice_keeps_the_bounds_and_averages_of_the_selection() {
let data = std::fs::read("data/with_hr.gpx").unwrap();
let file = parse(&data, &mut Default::default()).unwrap();
let segment = file.trk[0].trkseg[0].clone();
let s = Statistics::compute(&segment);
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
assert!(buffer.global.hr.count > 0);
let slice = buffer.slice(1, 3).unwrap();
let (global, bounds) = (&buffer.global, &slice.bounds);
assert_eq!(slice.hr, global.hr);
assert_eq!(slice.cad, global.cad);
assert_eq!(slice.atemp, global.atemp);
assert_eq!(slice.power, global.power);
assert_eq!(
(bounds.sw.lng, bounds.sw.lat),
(global.bounds.sw.lng, global.bounds.sw.lat)
);
assert_eq!(
(bounds.ne.lng, bounds.ne.lat),
(global.bounds.ne.lng, global.bounds.ne.lat)
);
}
#[test]
fn test_durations_are_not_limited_to_24_days() {
// 30 days of recording, in milliseconds
let (segment, mut s) = computed("data/with_time.gpx");
let month = 30 * 24 * 3_600_000_i64;
s.global.total_time = Some(month);
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s), (&segment, &s)]);
assert_eq!(buffer.global.total_time, Some(2 * month));
assert!(2 * month > i64::from(i32::MAX));
}
#[test]
fn test_slice_across_segments() {
let (segment, s) = computed("data/simple.gpx");
let n = s.local.len();
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s), (&segment, &s)]);
// from the middle of the first segment to the middle of the second one
let slice = buffer.slice(n / 2, n + n / 2).unwrap();
let expected = buffer.total_distance[n + n / 2] - buffer.total_distance[n / 2];
assert!((slice.total_distance - expected).abs() < 1e-9);
assert_eq!(slice.total_time, None);
}
#[test]
fn test_slice_out_of_range() {
let (segment, s) = computed("data/simple.gpx");
let mut buffer = StatisticsBuffer::default();
buffer.update(&[(&segment, &s)]);
let n = buffer.len();
assert!(buffer.slice(0, n).is_none());
assert!(buffer.slice(n, n).is_none());
assert!(buffer.slice(5, 4).is_none());
assert!(buffer.slice(0, n - 1).is_some());
}
}
@@ -1,7 +1,7 @@
use std::collections::{HashMap, HashSet, hash_map::Entry}; use std::collections::{HashMap, HashSet, hash_map::Entry};
use crate::{ use crate::{
File, FileId, Files, GlobalStatistics, Selection, Statistics, Track, TrackSegment, File, FileId, GlobalStatistics, Selection, StackEntry, Statistics, Track, TrackSegment,
TrackSegmentRevisionId, TrackSegmentRevisionId,
}; };
@@ -14,17 +14,19 @@ pub struct StatisticsCache {
} }
impl StatisticsCache { impl StatisticsCache {
pub fn update(&mut self, state: Option<&Files>) { pub fn update(&mut self, state: Option<&StackEntry>) {
let mut stale: HashSet<TrackSegmentRevisionId> = self.map.keys().copied().collect(); let mut stale: HashSet<TrackSegmentRevisionId> = self.map.keys().copied().collect();
if let Some(state) = state { if let Some(state) = state {
for file in state.values() { for file in state.values() {
for trkseg in file.segments() { for trk in file.trk.iter() {
match self.map.entry(trkseg.rev_id) { for trkseg in trk.trkseg.iter() {
Entry::Occupied(_) => { match self.map.entry(trkseg.rev_id) {
stale.remove(&trkseg.rev_id); Entry::Occupied(_) => {
} stale.remove(&trkseg.rev_id);
Entry::Vacant(e) => { }
e.insert(Statistics::compute(trkseg)); Entry::Vacant(e) => {
e.insert(Statistics::compute(trkseg));
}
} }
} }
} }
@@ -38,7 +40,7 @@ impl StatisticsCache {
/// Statistics of the segments of the selection. /// Statistics of the segments of the selection.
pub fn get<'a>( pub fn get<'a>(
&'a self, &'a self,
state: Option<&'a Files>, state: Option<&'a StackEntry>,
selection: &Selection, selection: &Selection,
) -> Vec<&'a Statistics> { ) -> Vec<&'a Statistics> {
self.selected(state, selection, &[]) self.selected(state, selection, &[])
@@ -51,7 +53,7 @@ impl StatisticsCache {
/// files follow `order` (the files missing from it come last). /// files follow `order` (the files missing from it come last).
pub fn selected<'a>( pub fn selected<'a>(
&'a self, &'a self,
state: Option<&'a Files>, state: Option<&'a StackEntry>,
selection: &Selection, selection: &Selection,
order: &[FileId], order: &[FileId],
) -> Vec<SelectedSegment<'a>> { ) -> Vec<SelectedSegment<'a>> {
@@ -70,15 +72,6 @@ impl StatisticsCache {
} }
} }
} }
Selection::Route { file_id, rte_ids } => {
if let Some(file) = state.get(file_id) {
for rte in file.rte.iter() {
if rte_ids.contains(&rte.id) {
self.add_segment_stats(&rte.seg, &mut selected);
}
}
}
}
Selection::Track { file_id, trk_ids } => { Selection::Track { file_id, trk_ids } => {
if let Some(file) = state.get(file_id) { if let Some(file) = state.get(file_id) {
for trk in file.trk.iter() { for trk in file.trk.iter() {
@@ -136,8 +129,8 @@ impl StatisticsCache {
} }
fn add_file_stats<'a>(&'a self, file: &'a File, selected: &mut Vec<SelectedSegment<'a>>) { fn add_file_stats<'a>(&'a self, file: &'a File, selected: &mut Vec<SelectedSegment<'a>>) {
for trkseg in file.segments() { for trk in file.trk.iter() {
self.add_segment_stats(trkseg, selected); self.add_track_stats(trk, selected);
} }
} }
@@ -166,10 +159,10 @@ mod tests {
use super::*; use super::*;
fn state(path: &str) -> (Files, Rc<File>) { fn state(path: &str) -> (StackEntry, Rc<File>) {
let data = std::fs::read(path).unwrap(); let data = std::fs::read(path).unwrap();
let file = Rc::new(parse(&data, &mut Default::default()).unwrap()); let file = Rc::new(parse(&data, &mut Default::default()).unwrap());
let mut state = Files::default(); let mut state = StackEntry::default();
state.insert(file.id, file.clone()); state.insert(file.id, file.clone());
(state, file) (state, file)
} }
@@ -242,7 +235,7 @@ mod tests {
let before: *const Statistics = cache.get(Some(&state), &file_selection(file.id))[0]; let before: *const Statistics = cache.get(Some(&state), &file_selection(file.id))[0];
// a new snapshot of the file that shares its segments (same revision ids) // a new snapshot of the file that shares its segments (same revision ids)
let mut next = Files::default(); let mut next = StackEntry::default();
let renamed = { let renamed = {
let mut f = (*file).clone(); let mut f = (*file).clone();
f.info.name = "other".to_string(); f.info.name = "other".to_string();
@@ -265,7 +258,7 @@ mod tests {
let mut f = (*file).clone(); let mut f = (*file).clone();
f.trk[0].trkseg[0].rev_id = Default::default(); f.trk[0].trkseg[0].rev_id = Default::default();
let new_rev = f.trk[0].trkseg[0].rev_id; let new_rev = f.trk[0].trkseg[0].rev_id;
let mut next = Files::default(); let mut next = StackEntry::default();
next.insert(f.id, Rc::new(f)); next.insert(f.id, Rc::new(f));
cache.update(Some(&next)); cache.update(Some(&next));
assert!(cache.map.contains_key(&new_rev)); assert!(cache.map.contains_key(&new_rev));
File diff suppressed because it is too large. Load diff
+11
View File
@@ -0,0 +1,11 @@
mod action;
mod command;
mod derived;
mod engine;
mod state;
pub use action::*;
pub use command::*;
pub use derived::*;
pub use engine::*;
pub use state::*;
@@ -3,18 +3,10 @@ use std::rc::Rc;
use uuid::Uuid; use uuid::Uuid;
use crate::{ use crate::{
File, FileId, Files, Route, RouteId, Selection, Track, TrackId, TrackSegment, TrackSegmentId, File, FileId, Selection, StackEntry, Track, TrackId, TrackSegment, TrackSegmentId, Waypoint,
Waypoint, WaypointId, WaypointId,
}; };
/// A route in the clipboard, with the name of the file it comes from (the name of the new file
/// when it is pasted on its own).
#[derive(Debug, Clone)]
pub struct ClipboardRoute {
pub route: Route,
pub file_name: String,
}
/// A track in the clipboard, with the name of the file it comes from (the name of the new file /// A track in the clipboard, with the name of the file it comes from (the name of the new file
/// when it is pasted on its own). /// when it is pasted on its own).
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@@ -39,7 +31,6 @@ pub struct ClipboardSegment {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum ClipboardContent { pub enum ClipboardContent {
Files(Vec<Rc<File>>), Files(Vec<Rc<File>>),
Routes(Vec<ClipboardRoute>),
Tracks(Vec<ClipboardTrack>), Tracks(Vec<ClipboardTrack>),
Segments(Vec<ClipboardSegment>), Segments(Vec<ClipboardSegment>),
Waypoints(Vec<Waypoint>), Waypoints(Vec<Waypoint>),
@@ -80,7 +71,7 @@ impl Clipboard {
/// selected does not exist). /// selected does not exist).
pub fn new( pub fn new(
selection: &Selection, selection: &Selection,
files: &Files, files: &StackEntry,
order: &[FileId], order: &[FileId],
cut: bool, cut: bool,
) -> Option<Clipboard> { ) -> Option<Clipboard> {
@@ -93,19 +84,6 @@ impl Clipboard {
.filter_map(|id| files.get(id).cloned()) .filter_map(|id| files.get(id).cloned())
.collect(), .collect(),
), ),
Selection::Route { file_id, rte_ids } => {
let file = files.get(file_id)?;
ClipboardContent::Routes(
file.rte
.iter()
.filter(|rte| rte_ids.contains(&rte.id))
.map(|rte| ClipboardRoute {
route: rte.clone(),
file_name: file.info.name.clone(),
})
.collect(),
)
}
Selection::Track { file_id, trk_ids } => { Selection::Track { file_id, trk_ids } => {
let file = files.get(file_id)?; let file = files.get(file_id)?;
ClipboardContent::Tracks( ClipboardContent::Tracks(
@@ -142,14 +120,20 @@ impl Clipboard {
.collect(), .collect(),
) )
} }
Selection::Waypoints { file_id } => { Selection::Waypoints { file_id } => ClipboardContent::Waypoints(
ClipboardContent::Waypoints(files.get(file_id)?.wpt.iter().cloned().collect()) files
} .get(file_id)?
.wpt
.iter()
.flat_map(|chunk| chunk.wpt.iter().cloned())
.collect(),
),
Selection::Waypoint { file_id, wpt_ids } => ClipboardContent::Waypoints( Selection::Waypoint { file_id, wpt_ids } => ClipboardContent::Waypoints(
files files
.get(file_id)? .get(file_id)?
.wpt .wpt
.iter() .iter()
.flat_map(|chunk| &chunk.wpt)
.filter(|wpt| wpt_ids.contains(&wpt.id)) .filter(|wpt| wpt_ids.contains(&wpt.id))
.cloned() .cloned()
.collect(), .collect(),
@@ -166,37 +150,32 @@ impl Clipboard {
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
match &self.content { match &self.content {
ClipboardContent::Files(files) => files.is_empty(), ClipboardContent::Files(files) => files.is_empty(),
ClipboardContent::Routes(routes) => routes.is_empty(),
ClipboardContent::Tracks(tracks) => tracks.is_empty(), ClipboardContent::Tracks(tracks) => tracks.is_empty(),
ClipboardContent::Segments(segments) => segments.is_empty(), ClipboardContent::Segments(segments) => segments.is_empty(),
ClipboardContent::Waypoints(waypoints) => waypoints.is_empty(), ClipboardContent::Waypoints(waypoints) => waypoints.is_empty(),
} }
} }
/// Whether the content can be pasted when `target` is selected: files, routes and tracks can /// Whether the content can be pasted when `target` is selected: files and tracks can be
/// be pasted anywhere above them in the file tree (routes and tracks are at the same level), /// pasted anywhere above them in the file tree, and nothing selected stands for the list of
/// and nothing selected stands for the list of files. /// files.
/// ///
/// | copied | pasted when selected | /// | copied | pasted when selected |
/// |-----------|-----------------------------------------------| /// |-----------|------------------------------------------|
/// | files | nothing, a file | /// | files | nothing, a file |
/// | routes | nothing, a file, a route, a track | /// | tracks | nothing, a file, a track |
/// | tracks | nothing, a file, a route, a track | /// | segments | nothing, a file, a track, a segment |
/// | segments | nothing, a file, a route, a track, a segment | /// | waypoints | a file, the waypoints, a waypoint |
/// | waypoints | a file, the waypoints, a waypoint |
pub fn can_paste(&self, target: &Selection) -> bool { pub fn can_paste(&self, target: &Selection) -> bool {
use ClipboardContent as C; use ClipboardContent as C;
use Selection::*; use Selection::*;
matches!( matches!(
(&self.content, target), (&self.content, target),
(C::Files(_), Empty | File { .. }) (C::Files(_), Empty | File { .. })
| ( | (C::Tracks(_), Empty | File { .. } | Track { .. })
C::Routes(_) | C::Tracks(_),
Empty | File { .. } | Route { .. } | Track { .. }
)
| ( | (
C::Segments(_), C::Segments(_),
Empty | File { .. } | Route { .. } | Track { .. } | TrackSegment { .. } Empty | File { .. } | Track { .. } | TrackSegment { .. }
) )
| ( | (
C::Waypoints(_), C::Waypoints(_),
@@ -210,7 +189,6 @@ impl Clipboard {
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub enum ClipboardIds { pub enum ClipboardIds {
Files(Vec<FileId>), Files(Vec<FileId>),
Routes(Vec<RouteId>),
Tracks(Vec<TrackId>), Tracks(Vec<TrackId>),
Segments(Vec<TrackSegmentId>), Segments(Vec<TrackSegmentId>),
Waypoints(Vec<WaypointId>), Waypoints(Vec<WaypointId>),
@@ -222,9 +200,6 @@ impl ClipboardContent {
ClipboardContent::Files(files) => { ClipboardContent::Files(files) => {
ClipboardIds::Files(files.iter().map(|file| file.id).collect()) ClipboardIds::Files(files.iter().map(|file| file.id).collect())
} }
ClipboardContent::Routes(routes) => {
ClipboardIds::Routes(routes.iter().map(|rte| rte.route.id).collect())
}
ClipboardContent::Tracks(tracks) => { ClipboardContent::Tracks(tracks) => {
ClipboardIds::Tracks(tracks.iter().map(|trk| trk.track.id).collect()) ClipboardIds::Tracks(tracks.iter().map(|trk| trk.track.id).collect())
} }
@@ -258,25 +233,25 @@ mod tests {
..Default::default() ..Default::default()
}); });
} }
file.wpt.push(WaypointChunk { file.wpt.push(Rc::new(WaypointChunk {
wpt: vec![Waypoint::default(), Waypoint::default()], wpt: vec![Waypoint::default(), Waypoint::default()],
..Default::default() ..Default::default()
}); }));
file.wpt.push(WaypointChunk { file.wpt.push(Rc::new(WaypointChunk {
wpt: vec![Waypoint::default()], wpt: vec![Waypoint::default()],
..Default::default() ..Default::default()
}); }));
file file
} }
fn files_of(files: Vec<File>) -> Files { fn files_of(files: Vec<File>) -> StackEntry {
files files
.into_iter() .into_iter()
.map(|file| (file.id, Rc::new(file))) .map(|file| (file.id, Rc::new(file)))
.collect() .collect()
} }
fn order_of(files: &Files) -> Vec<FileId> { fn order_of(files: &StackEntry) -> Vec<FileId> {
files.keys().copied().collect() files.keys().copied().collect()
} }
@@ -292,7 +267,11 @@ mod tests {
let file = file("source"); let file = file("source");
let (t0, t2) = (file.trk[0].id, file.trk[2].id); let (t0, t2) = (file.trk[0].id, file.trk[2].id);
let (s0, s1) = (file.trk[1].trkseg[0].id, file.trk[1].trkseg[1].id); let (s0, s1) = (file.trk[1].trkseg[0].id, file.trk[1].trkseg[1].id);
let wpt: Vec<_> = file.wpt.iter().map(|w| w.id).collect(); let wpt: Vec<_> = file
.wpt
.iter()
.flat_map(|c| c.wpt.iter().map(|w| w.id))
.collect();
let files = files_of(vec![file.clone()]); let files = files_of(vec![file.clone()]);
// tracks, in the order of the file, with the name of their file // tracks, in the order of the file, with the name of their file
@@ -468,7 +447,7 @@ mod tests {
let waypoints = Selection::Waypoints { file_id: file.id }; let waypoints = Selection::Waypoints { file_id: file.id };
let waypoint = Selection::Waypoint { let waypoint = Selection::Waypoint {
file_id: file.id, file_id: file.id,
wpt_ids: [file.wpt[0].id].into(), wpt_ids: [file.wpt[0].wpt[0].id].into(),
}; };
let targets = [ let targets = [
Selection::Empty, Selection::Empty,
@@ -1,16 +1,16 @@
mod clipboard; mod clipboard;
mod history;
mod order; mod order;
mod selection; mod selection;
mod stack;
pub use clipboard::*; pub use clipboard::*;
pub use history::*;
pub use order::*; pub use order::*;
pub use selection::*; pub use selection::*;
pub use stack::*;
pub struct State<'a> { pub struct State<'a> {
pub categories: &'a mut crate::TrackpointCategories, pub categories: &'a mut crate::TrackpointCategories,
pub files: &'a mut Files, pub files: &'a mut StackEntry,
pub selection: &'a mut Selection, pub selection: &'a mut Selection,
pub order: &'a mut FileOrder, pub order: &'a mut FileOrder,
pub clipboard: &'a mut Option<Clipboard>, pub clipboard: &'a mut Option<Clipboard>,
Loaded 100 of 809 files, more files were not shown because too many files have changed in this diff. Show more