comparing f3a68c3b171c14a66616ccf3790add13fcfce62d and main on anil.recoil.org/ocaml-gpx

+32 -11

.tangled/workflows/build.yml

···

       5
       5
        
       dependencies:

     

       6
       6
        
         nixpkgs:

     

       7
       7
        
           - shell

     

       8
       8
       +
           - stdenv

     

       9
       9
       +
           - findutils

     

       10
       10
       +
           - binutils

     

       11
       11
       +
           - libunwind

     

       12
       12
       +
           - ncurses

     

       13
       13
       +
           - opam

     

       14
       14
       +
           - git

     

       15
       15
       +
           - gawk

     

       16
       16
       +
           - gnupatch

     

       17
       17
       +
           - gnum4

     

       18
       18
       +
           - gnumake

     

       19
       19
       +
           - gnutar

     

       20
       20
       +
           - gnused

     

       21
       21
       +
           - gnugrep

     

       22
       22
       +
           - diffutils

     

       23
       23
       +
           - gzip

     

       24
       24
       +
           - bzip2

     

       8
       25
        
           - gcc

     

       9
       9
       -
           - dune_3

     

       10
       26
        
           - ocaml

     

       11
       11
       -
           - ocamlpackages.xmlm

     

       12
       12
       -
           - ocamlpackages.alcotest

     

       13
       13
       -
           - ocamlpackages.eio

     

       14
       14
       -
           - ocamlpackages.fmt

     

       15
       15
       -
           - ocamlpackages.eio_main

     

       16
       16
       -
           - ocamlpackages.ppx_expect

     

       17
       17
       -
           - ocamlpackages.cmdliner

     

       18
       18
       -
           - ocamlpackages.ptime

     

       19
       27
        
       

     

       20
       28
        
       steps:

     

       21
       21
       -
         - name: dune

     

       29
       29
       +
         - name: opam

     

       30
       30
       +
           command: |

     

       31
       31
       +
              opam init --disable-sandboxing -any

     

       32
       32
       +
         - name: switch

     

       33
       33
       +
           command: |

     

       34
       34
       +
              opam install . --confirm-level=unsafe-yes --deps-only

     

       35
       35
       +
         - name: build

     

       36
       36
       +
           command: |

     

       37
       37
       +
              opam exec -- dune build --verbose

     

       38
       38
       +
         - name: test

     

       22
       39
        
           command: |

     

       23
       23
       -
              dune build

     

       40
       40
       +
              opam exec -- dune runtest --verbose

     

       41
       41
       +
         - name: doc

     

       42
       42
       +
           command: |

     

       43
       43
       +
              opam install -y odoc

     

       44
       44
       +
              opam exec -- dune build @doc

+1 -1

CHANGES.md

···

       1
       1
       -
       # dev

     

       1
       1
       +
       # v1.0.0

     

       2
       2
        
       

     

       3
       3
        
       - Initial public release

+2 -4

README.md

···

       14
       14
        
       dune build @install

     

       15
       15
        
       dune install

     

       16
       16
        
       

     

       17
       17
       -
       # Or use opam (when published)

     

       17
       17
       +
       # Or use opam

     

       18
       18
        
       opam install mlgpx

     

       19
       19
        
       ```

     

       20
       20
        
       

     
···

       63
       63
        
       The library is split into four main components:

     

       64
       64
        
       

     

       65
       65
        
       ### Core Library (`gpx`)

     

       66
       66
       -
       - **Portable**: No Unix dependencies, works with js_of_ocaml

     

       66
       66
       +
       - **Portable**: No Unix dependencies, works with `js_of_ocaml`

     

       67
       67
        
       - **Streaming**: Uses xmlm for memory-efficient XML processing

     

       68
       68
        
       - **Type-safe**: Strong typing with validation for coordinates and GPS data

     

       69
       69
        
       - **Pure functional**: No side effects in the core parsing/writing logic

     
···

       283
       283
        
       

     

       284
       284
        
       let () = create_simple_gpx ()

     

       285
       285
        
       ```

     

       286
       286
       -
       

     

       287
       287
       -

+1 -1

bin/dune

···

       1
       1
        
       (executable

     

       2
       2
        
        (public_name mlgpx)

     

       3
       3
        
        (name mlgpx_cli)

     

       4
       4
       -
        (libraries gpx gpx_eio cmdliner eio_main fmt fmt.tty fmt.cli))
     

       4
       4
       +
        (libraries gpx gpx_eio cmdliner eio_main fmt fmt.tty fmt.cli))

+450 -1

bin/mlgpx_cli.ml

···

       1
       1
       -
       (* Temporarily disabled during refactoring *)

     

       1
       1
       +
       (** mlgpx Command Line Interface with pretty ANSI output *)

     

       2
       2
       +
       

     

       3
       3
       +
       open Cmdliner

     

       4
       4
       +
       open Gpx

     

       5
       5
       +
       

     

       6
       6
       +
       (* Terminal and formatting setup *)

     

       7
       7
       +
       let setup_fmt style_renderer =

     

       8
       8
       +
         Fmt_tty.setup_std_outputs ?style_renderer ();

     

       9
       9
       +
         ()

     

       10
       10
       +
       

     

       11
       11
       +
       (* Color formatters *)

     

       12
       12
       +
       let info_style = Fmt.(styled (`Fg `Green))

     

       13
       13
       +
       let warn_style = Fmt.(styled (`Fg `Yellow))

     

       14
       14
       +
       let error_style = Fmt.(styled (`Fg `Red))

     

       15
       15
       +
       let success_style = Fmt.(styled (`Fg `Green))

     

       16
       16
       +
       let bold_style = Fmt.(styled `Bold)

     

       17
       17
       +
       

     

       18
       18
       +
       (* Logging functions *)

     

       19
       19
       +
       let log_info fmt = 

     

       20
       20
       +
         Fmt.pf Format.err_formatter "[%a] " (info_style Fmt.string) "INFO";

     

       21
       21
       +
         Format.kfprintf (fun fmt -> Format.pp_print_newline fmt (); Format.pp_print_flush fmt ()) Format.err_formatter fmt

     

       22
       22
       +
       

     

       23
       23
       +
       

     

       24
       24
       +
       let log_error fmt = 

     

       25
       25
       +
         Fmt.pf Format.err_formatter "[%a] " (error_style Fmt.string) "ERROR";

     

       26
       26
       +
         Format.kfprintf (fun fmt -> Format.pp_print_newline fmt (); Format.pp_print_flush fmt ()) Format.err_formatter fmt

     

       27
       27
       +
       

     

       28
       28
       +
       let log_success fmt = 

     

       29
       29
       +
         Format.kfprintf (fun fmt -> Format.pp_print_newline fmt (); Format.pp_print_flush fmt ()) Format.std_formatter fmt

     

       30
       30
       +
       

     

       31
       31
       +
       (* Utility functions *)

     

       32
       32
       +
       let waypoints_to_track_segments waypoints =

     

       33
       33
       +
         if waypoints = [] then

     

       34
       34
       +
           []

     

       35
       35
       +
         else

     

       36
       36
       +
           Track.Segment.make waypoints :: []

     

       37
       37
       +
       

     

       38
       38
       +
       let sort_waypoints sort_by_time sort_by_name waypoints =

     

       39
       39
       +
         if sort_by_time then

     

       40
       40
       +
           List.sort (fun wpt1 wpt2 ->

     

       41
       41
       +
             match Waypoint.time wpt1, Waypoint.time wpt2 with

     

       42
       42
       +
             | Some t1, Some t2 -> Ptime.compare t1 t2

     

       43
       43
       +
             | Some _, None -> -1

     

       44
       44
       +
             | None, Some _ -> 1

     

       45
       45
       +
             | None, None -> 0

     

       46
       46
       +
           ) waypoints

     

       47
       47
       +
         else if sort_by_name then

     

       48
       48
       +
           List.sort (fun wpt1 wpt2 ->

     

       49
       49
       +
             match Waypoint.name wpt1, Waypoint.name wpt2 with

     

       50
       50
       +
             | Some n1, Some n2 -> String.compare n1 n2

     

       51
       51
       +
             | Some _, None -> -1

     

       52
       52
       +
             | None, Some _ -> 1

     

       53
       53
       +
             | None, None -> 0

     

       54
       54
       +
           ) waypoints

     

       55
       55
       +
         else

     

       56
       56
       +
           waypoints

     

       57
       57
       +
       

     

       58
       58
       +
       (* Main conversion command *)

     

       59
       59
       +
       let convert_waypoints_to_trackset input_file output_file track_name track_desc 

     

       60
       60
       +
                                         sort_by_time sort_by_name preserve_waypoints verbose style_renderer =

     

       61
       61
       +
         setup_fmt style_renderer;

     

       62
       62
       +
         let run env =

     

       63
       63
       +
           try

     

       64
       64
       +
             let fs = Eio.Stdenv.fs env in

     

       65
       65
       +
             

     

       66
       66
       +
             if verbose then

     

       67
       67
       +
               log_info "Reading GPX file: %a" (bold_style Fmt.string) input_file;

     

       68
       68
       +
             

     

       69
       69
       +
             (* Read input GPX *)

     

       70
       70
       +
             let gpx = Gpx_eio.read ~fs input_file in

     

       71
       71
       +
             

     

       72
       72
       +
             if verbose then

     

       73
       73
       +
               log_info "Found %d waypoints and %d existing tracks" 

     

       74
       74
       +
                 (Doc.waypoint_count gpx)

     

       75
       75
       +
                 (Doc.track_count gpx);

     

       76
       76
       +
             

     

       77
       77
       +
             (* Check if we have waypoints to convert *)

     

       78
       78
       +
             if Doc.waypoints gpx = [] then (

     

       79
       79
       +
               log_error "Input file contains no waypoints - nothing to convert";

     

       80
       80
       +
               exit 1

     

       81
       81
       +
             );

     

       82
       82
       +
             

     

       83
       83
       +
             (* Sort waypoints if requested *)

     

       84
       84
       +
             let sorted_waypoints = sort_waypoints sort_by_time sort_by_name (Doc.waypoints gpx) in

     

       85
       85
       +
             

     

       86
       86
       +
             if verbose && (sort_by_time || sort_by_name) then

     

       87
       87
       +
               log_info "Sorted %d waypoints" (List.length sorted_waypoints);

     

       88
       88
       +
             

     

       89
       89
       +
             (* Convert waypoints to track segments *)

     

       90
       90
       +
             let track_segments = waypoints_to_track_segments sorted_waypoints in

     

       91
       91
       +
             

     

       92
       92
       +
             (* Create the new track *)

     

       93
       93
       +
             let new_track = Track.make ~name:track_name in

     

       94
       94
       +
             let new_track = { new_track with 

     

       95
       95
       +
               cmt = Some "Generated from waypoints by mlgpx CLI";

     

       96
       96
       +
               desc = track_desc;

     

       97
       97
       +
               src = Some "mlgpx";

     

       98
       98
       +
               type_ = Some "converted";

     

       99
       99
       +
               trksegs = track_segments;

     

       100
       100
       +
             } in

     

       101
       101
       +
             

     

       102
       102
       +
             if verbose then (

     

       103
       103
       +
               let total_points = List.fold_left (fun acc seg -> acc + Track.Segment.point_count seg) 0 track_segments in

     

       104
       104
       +
               log_info "Created track %a with %d segments containing %d points"

     

       105
       105
       +
                 (bold_style Fmt.string) track_name

     

       106
       106
       +
                 (List.length track_segments) total_points

     

       107
       107
       +
             );

     

       108
       108
       +
             

     

       109
       109
       +
             (* Build output GPX *)

     

       110
       110
       +
             let output_gpx = 

     

       111
       111
       +
               if preserve_waypoints then

     

       112
       112
       +
                 Doc.add_track gpx new_track

     

       113
       113
       +
               else

     

       114
       114
       +
                 Doc.add_track (Doc.clear_waypoints gpx) new_track in

     

       115
       115
       +
             let output_gpx = 

     

       116
       116
       +
               match Doc.metadata gpx with

     

       117
       117
       +
                 | Some meta -> 

     

       118
       118
       +
                     let desc = match Metadata.description meta with

     

       119
       119
       +
                       | Some existing -> existing ^ " (waypoints converted to track)"

     

       120
       120
       +
                       | None -> "Waypoints converted to track" in

     

       121
       121
       +
                     Doc.with_metadata output_gpx { meta with desc = Some desc }

     

       122
       122
       +
                 | None -> 

     

       123
       123
       +
                     let meta = Metadata.make ~name:"Converted" in

     

       124
       124
       +
                     let meta = { meta with desc = Some "Waypoints converted to track" } in

     

       125
       125
       +
                     Doc.with_metadata output_gpx meta in

     

       126
       126
       +
             

     

       127
       127
       +
             (* Validate output *)

     

       128
       128
       +
             let validation = Gpx.validate_gpx output_gpx in

     

       129
       129
       +
             if not validation.is_valid then (

     

       130
       130
       +
               log_error "Generated GPX failed validation:";

     

       131
       131
       +
               List.iter (fun (issue : Gpx.validation_issue) ->

     

       132
       132
       +
                 let level_str = match issue.level with `Error -> "ERROR" | `Warning -> "WARNING" in

     

       133
       133
       +
                 let level_color = match issue.level with `Error -> error_style | `Warning -> warn_style in

     

       134
       134
       +
                 Fmt.pf Format.err_formatter "  %a: %s\n" (level_color Fmt.string) level_str issue.message

     

       135
       135
       +
               ) validation.issues;

     

       136
       136
       +
               exit 1

     

       137
       137
       +
             );

     

       138
       138
       +
             

     

       139
       139
       +
             if verbose then

     

       140
       140
       +
               log_info "Writing output to: %a" (bold_style Fmt.string) output_file;

     

       141
       141
       +
             

     

       142
       142
       +
             (* Write output GPX *)

     

       143
       143
       +
             Gpx_eio.write ~fs output_file output_gpx;

     

       144
       144
       +
             

     

       145
       145
       +
             if verbose then (

     

       146
       146
       +
               Fmt.pf Format.std_formatter "%a\n" (success_style Fmt.string) "Conversion completed successfully!";

     

       147
       147
       +
               log_info "Output contains:";

     

       148
       148
       +
               Fmt.pf Format.err_formatter "  - %d waypoints%s\n" 

     

       149
       149
       +
                 (Doc.waypoint_count output_gpx)

     

       150
       150
       +
                 (if preserve_waypoints then " (preserved)" else " (removed)");

     

       151
       151
       +
               Fmt.pf Format.err_formatter "  - %d tracks (%a + %d existing)\n"

     

       152
       152
       +
                 (Doc.track_count output_gpx)

     

       153
       153
       +
                 (success_style Fmt.string) "1 new"

     

       154
       154
       +
                 (Doc.track_count gpx)

     

       155
       155
       +
             ) else (

     

       156
       156
       +
               log_success "Converted %d waypoints to track: %a → %a" 

     

       157
       157
       +
                 (List.length sorted_waypoints)

     

       158
       158
       +
                 (bold_style Fmt.string) input_file

     

       159
       159
       +
                 (bold_style Fmt.string) output_file

     

       160
       160
       +
             )

     

       161
       161
       +
             

     

       162
       162
       +
           with

     

       163
       163
       +
           | Gpx.Gpx_error err ->

     

       164
       164
       +
               log_error "GPX Error: %s" (Error.to_string err);

     

       165
       165
       +
               exit 2

     

       166
       166
       +
           | Sys_error msg ->

     

       167
       167
       +
               log_error "System error: %s" msg;

     

       168
       168
       +
               exit 2

     

       169
       169
       +
           | exn ->

     

       170
       170
       +
               log_error "Unexpected error: %s" (Printexc.to_string exn);

     

       171
       171
       +
               exit 2

     

       172
       172
       +
         in

     

       173
       173
       +
         Eio_main.run run

     

       174
       174
       +
       

     

       175
       175
       +
       (* Helper function to collect all timestamps from GPX *)

     

       176
       176
       +
       let collect_all_timestamps gpx =

     

       177
       177
       +
         let times = ref [] in

     

       178
       178
       +
         

     

       179
       179
       +
         (* Collect from waypoints *)

     

       180
       180
       +
         List.iter (fun wpt ->

     

       181
       181
       +
           match Waypoint.time wpt with

     

       182
       182
       +
           | Some t -> times := t :: !times

     

       183
       183
       +
           | None -> ()

     

       184
       184
       +
         ) (Doc.waypoints gpx);

     

       185
       185
       +
         

     

       186
       186
       +
         (* Collect from routes *)

     

       187
       187
       +
         List.iter (fun route ->

     

       188
       188
       +
           List.iter (fun rtept ->

     

       189
       189
       +
             match Waypoint.time rtept with

     

       190
       190
       +
             | Some t -> times := t :: !times

     

       191
       191
       +
             | None -> ()

     

       192
       192
       +
           ) (Route.points route)

     

       193
       193
       +
         ) (Doc.routes gpx);

     

       194
       194
       +
         

     

       195
       195
       +
         (* Collect from tracks *)

     

       196
       196
       +
         List.iter (fun track ->

     

       197
       197
       +
           List.iter (fun seg ->

     

       198
       198
       +
             List.iter (fun trkpt ->

     

       199
       199
       +
               match Waypoint.time trkpt with

     

       200
       200
       +
               | Some t -> times := t :: !times

     

       201
       201
       +
               | None -> ()

     

       202
       202
       +
             ) (Track.Segment.points seg)

     

       203
       203
       +
           ) (Track.segments track)

     

       204
       204
       +
         ) (Doc.tracks gpx);

     

       205
       205
       +
         

     

       206
       206
       +
         !times

     

       207
       207
       +
       

     

       208
       208
       +
       (* Info command *)

     

       209
       209
       +
       let info_command input_file verbose style_renderer =

     

       210
       210
       +
         setup_fmt style_renderer;

     

       211
       211
       +
         let run env =

     

       212
       212
       +
           try

     

       213
       213
       +
             let fs = Eio.Stdenv.fs env in

     

       214
       214
       +
             

     

       215
       215
       +
             if verbose then

     

       216
       216
       +
               log_info "Analyzing GPX file: %a" (bold_style Fmt.string) input_file;

     

       217
       217
       +
             

     

       218
       218
       +
             let gpx = Gpx_eio.read ~fs input_file in

     

       219
       219
       +
             

     

       220
       220
       +
             (* Header *)

     

       221
       221
       +
             Fmt.pf Format.std_formatter "%a\n" (bold_style Fmt.string) "GPX File Information";

     

       222
       222
       +
             

     

       223
       223
       +
             (* Basic info *)

     

       224
       224
       +
             Printf.printf "  Version: %s\n" (Doc.version gpx);

     

       225
       225
       +
             Printf.printf "  Creator: %s\n" (Doc.creator gpx);

     

       226
       226
       +
             

     

       227
       227
       +
             (match Doc.metadata gpx with

     

       228
       228
       +
              | Some meta ->

     

       229
       229
       +
                  Printf.printf "  Name: %s\n" (Option.value (Metadata.name meta) ~default:"<unnamed>");

     

       230
       230
       +
                  Printf.printf "  Description: %s\n" (Option.value (Metadata.description meta) ~default:"<none>");

     

       231
       231
       +
                  (match Metadata.time meta with

     

       232
       232
       +
                   | Some time -> Printf.printf "  Created: %s\n" (Ptime.to_rfc3339 time)

     

       233
       233
       +
                   | None -> ())

     

       234
       234
       +
              | None -> 

     

       235
       235
       +
                  Printf.printf "  No metadata\n");

     

       236
       236
       +
             

     

       237
       237
       +
             (* Content summary *)

     

       238
       238
       +
             Fmt.pf Format.std_formatter "\n%a\n" (bold_style Fmt.string) "Content Summary";

     

       239
       239
       +
             Printf.printf "  Waypoints: %d\n" (Doc.waypoint_count gpx);

     

       240
       240
       +
             Printf.printf "  Routes: %d\n" (Doc.route_count gpx);

     

       241
       241
       +
             Printf.printf "  Tracks: %d\n" (Doc.track_count gpx);

     

       242
       242
       +
             

     

       243
       243
       +
             (* Time range *)

     

       244
       244
       +
             let all_times = collect_all_timestamps gpx in

     

       245
       245
       +
             if all_times <> [] then (

     

       246
       246
       +
               let sorted_times = List.sort Ptime.compare all_times in

     

       247
       247
       +
               let start_time = List.hd sorted_times in

     

       248
       248
       +
               let stop_time = List.hd (List.rev sorted_times) in

     

       249
       249
       +
               

     

       250
       250
       +
               Fmt.pf Format.std_formatter "\n%a\n" (bold_style Fmt.string) "Time Range";

     

       251
       251
       +
               Fmt.pf Format.std_formatter "  Start: %a\n" (info_style Fmt.string) (Ptime.to_rfc3339 start_time);

     

       252
       252
       +
               Fmt.pf Format.std_formatter "  Stop:  %a\n" (info_style Fmt.string) (Ptime.to_rfc3339 stop_time);

     

       253
       253
       +
               

     

       254
       254
       +
               (* Calculate duration *)

     

       255
       255
       +
               let duration_span = Ptime.diff stop_time start_time in

     

       256
       256
       +
               match Ptime.Span.to_int_s duration_span with

     

       257
       257
       +
               | Some seconds ->

     

       258
       258
       +
                   let days = seconds / 86400 in

     

       259
       259
       +
                   let hours = (seconds mod 86400) / 3600 in

     

       260
       260
       +
                   let minutes = (seconds mod 3600) / 60 in

     

       261
       261
       +
                   

     

       262
       262
       +
                   if days > 0 then

     

       263
       263
       +
                     Fmt.pf Format.std_formatter "  Duration: %a\n" (bold_style Fmt.string) 

     

       264
       264
       +
                       (Printf.sprintf "%d days, %d hours, %d minutes" days hours minutes)

     

       265
       265
       +
                   else if hours > 0 then

     

       266
       266
       +
                     Fmt.pf Format.std_formatter "  Duration: %a\n" (bold_style Fmt.string)

     

       267
       267
       +
                       (Printf.sprintf "%d hours, %d minutes" hours minutes)

     

       268
       268
       +
                   else

     

       269
       269
       +
                     Fmt.pf Format.std_formatter "  Duration: %a\n" (bold_style Fmt.string)

     

       270
       270
       +
                       (Printf.sprintf "%d minutes" minutes)

     

       271
       271
       +
               | None ->

     

       272
       272
       +
                   (* Duration too large to represent as int *)

     

       273
       273
       +
                   Fmt.pf Format.std_formatter "  Duration: %a\n" (bold_style Fmt.string) 

     

       274
       274
       +
                     (Printf.sprintf "%.1f days" (Ptime.Span.to_float_s duration_span /. 86400.));

     

       275
       275
       +
               

     

       276
       276
       +
               Printf.printf "  Total points with timestamps: %d\n" (List.length all_times)

     

       277
       277
       +
             );

     

       278
       278
       +
             

     

       279
       279
       +
             (* Detailed waypoint info *)

     

       280
       280
       +
             if Doc.waypoints gpx <> [] then (

     

       281
       281
       +
               Fmt.pf Format.std_formatter "\n%a\n" (bold_style Fmt.string) "Waypoints";

     

       282
       282
       +
               let waypoints_with_time = List.filter (fun wpt -> Waypoint.time wpt <> None) (Doc.waypoints gpx) in

     

       283
       283
       +
               let waypoints_with_elevation = List.filter (fun wpt -> Waypoint.elevation wpt <> None) (Doc.waypoints gpx) in

     

       284
       284
       +
               Printf.printf "  - %d with timestamps\n" (List.length waypoints_with_time);

     

       285
       285
       +
               Printf.printf "  - %d with elevation data\n" (List.length waypoints_with_elevation);

     

       286
       286
       +
               

     

       287
       287
       +
               if verbose && List.length (Doc.waypoints gpx) <= 10 then (

     

       288
       288
       +
                 Printf.printf "  Details:\n";

     

       289
       289
       +
                 List.iteri (fun i wpt ->

     

       290
       290
       +
                   let lat, lon = Waypoint.to_floats wpt in

     

       291
       291
       +
                   Fmt.pf Format.std_formatter "    %a %s (%.6f, %.6f)%s%s\n" 

     

       292
       292
       +
                     (info_style Fmt.string) (Printf.sprintf "%d." (i + 1))

     

       293
       293
       +
                     (Option.value (Waypoint.name wpt) ~default:"<unnamed>")

     

       294
       294
       +
                     lat lon

     

       295
       295
       +
                     (match Waypoint.elevation wpt with Some e -> Printf.sprintf " elev=%.1fm" e | None -> "")

     

       296
       296
       +
                     (match Waypoint.time wpt with Some t -> " @" ^ Ptime.to_rfc3339 t | None -> "")

     

       297
       297
       +
                 ) (Doc.waypoints gpx)

     

       298
       298
       +
               )

     

       299
       299
       +
             );

     

       300
       300
       +
             

     

       301
       301
       +
             (* Track info *)

     

       302
       302
       +
             if Doc.tracks gpx <> [] then (

     

       303
       303
       +
               Fmt.pf Format.std_formatter "\n%a\n" (bold_style Fmt.string) "Tracks";

     

       304
       304
       +
               List.iteri (fun i track ->

     

       305
       305
       +
                 let total_points = Track.point_count track in

     

       306
       306
       +
                 Fmt.pf Format.std_formatter "  %a %s (%d segments, %d points)\n"

     

       307
       307
       +
                   (info_style Fmt.string) (Printf.sprintf "%d." (i + 1))

     

       308
       308
       +
                   (Option.value (Track.name track) ~default:"<unnamed>")

     

       309
       309
       +
                   (Track.segment_count track) total_points

     

       310
       310
       +
               ) (Doc.tracks gpx)

     

       311
       311
       +
             );

     

       312
       312
       +
             

     

       313
       313
       +
             (* Validation *)

     

       314
       314
       +
             let validation = Gpx.validate_gpx gpx in

     

       315
       315
       +
             Printf.printf "\n";

     

       316
       316
       +
             if validation.is_valid then

     

       317
       317
       +
               Fmt.pf Format.std_formatter "Validation: %a\n" (success_style Fmt.string) "PASSED"

     

       318
       318
       +
             else (

     

       319
       319
       +
               Fmt.pf Format.std_formatter "Validation: %a\n" (error_style Fmt.string) "FAILED";

     

       320
       320
       +
               List.iter (fun (issue : Gpx.validation_issue) ->

     

       321
       321
       +
                 let level_str = match issue.level with `Error -> "ERROR" | `Warning -> "WARNING" in

     

       322
       322
       +
                 let level_color = match issue.level with `Error -> error_style | `Warning -> warn_style in

     

       323
       323
       +
                 Fmt.pf Format.std_formatter "  %a: %s\n" (level_color Fmt.string) level_str issue.message

     

       324
       324
       +
               ) validation.issues

     

       325
       325
       +
             )

     

       326
       326
       +
             

     

       327
       327
       +
           with

     

       328
       328
       +
           | Gpx.Gpx_error err ->

     

       329
       329
       +
               log_error "GPX Error: %s" (Error.to_string err);

     

       330
       330
       +
               exit 2

     

       331
       331
       +
           | Sys_error msg ->

     

       332
       332
       +
               log_error "System error: %s" msg;

     

       333
       333
       +
               exit 2

     

       334
       334
       +
           | exn ->

     

       335
       335
       +
               log_error "Unexpected error: %s" (Printexc.to_string exn);

     

       336
       336
       +
               exit 2

     

       337
       337
       +
         in

     

       338
       338
       +
         Eio_main.run run

     

       339
       339
       +
       

     

       340
       340
       +
       (* CLI argument definitions *)

     

       341
       341
       +
       let input_file_arg =

     

       342
       342
       +
         let doc = "Input GPX file path" in

     

       343
       343
       +
         Arg.(required & pos 0 (some non_dir_file) None & info [] ~docv:"INPUT" ~doc)

     

       344
       344
       +
       

     

       345
       345
       +
       let output_file_arg =

     

       346
       346
       +
         let doc = "Output GPX file path" in

     

       347
       347
       +
         Arg.(required & pos 1 (some string) None & info [] ~docv:"OUTPUT" ~doc)

     

       348
       348
       +
       

     

       349
       349
       +
       let track_name_opt =

     

       350
       350
       +
         let doc = "Name for the generated track (default: \"Converted from waypoints\")" in

     

       351
       351
       +
         Arg.(value & opt string "Converted from waypoints" & info ["n"; "name"] ~docv:"NAME" ~doc)

     

       352
       352
       +
       

     

       353
       353
       +
       let track_description_opt =

     

       354
       354
       +
         let doc = "Description for the generated track" in

     

       355
       355
       +
         Arg.(value & opt (some string) None & info ["d"; "desc"] ~docv:"DESC" ~doc)

     

       356
       356
       +
       

     

       357
       357
       +
       let sort_by_time_flag =

     

       358
       358
       +
         let doc = "Sort waypoints by timestamp before conversion" in

     

       359
       359
       +
         Arg.(value & flag & info ["t"; "sort-time"] ~doc)

     

       360
       360
       +
       

     

       361
       361
       +
       let sort_by_name_flag =

     

       362
       362
       +
         let doc = "Sort waypoints by name before conversion" in

     

       363
       363
       +
         Arg.(value & flag & info ["sort-name"] ~doc)

     

       364
       364
       +
       

     

       365
       365
       +
       let preserve_waypoints_flag =

     

       366
       366
       +
         let doc = "Keep original waypoints in addition to generated track" in

     

       367
       367
       +
         Arg.(value & flag & info ["p"; "preserve"] ~doc)

     

       368
       368
       +
       

     

       369
       369
       +
       let verbose_flag =

     

       370
       370
       +
         let doc = "Enable verbose output" in

     

       371
       371
       +
         Arg.(value & flag & info ["v"; "verbose"] ~doc)

     

       372
       372
       +
       

     

       373
       373
       +
       (* Command definitions *)

     

       374
       374
       +
       let convert_cmd =

     

       375
       375
       +
         let doc = "Convert waypoints to trackset" in

     

       376
       376
       +
         let man = [

     

       377
       377
       +
           `S Manpage.s_description;

     

       378
       378
       +
           `P "Convert all waypoints in a GPX file to a single track. This is useful for \

     

       379
       379
       +
               converting a collection of waypoints into a navigable route or for \

     

       380
       380
       +
               consolidating GPS data.";

     

       381
       381
       +
           `P "The conversion preserves all waypoint data (coordinates, elevation, \

     

       382
       382
       +
               timestamps, etc.) in the track points. By default, waypoints are removed \

     

       383
       383
       +
               from the output file unless --preserve is used.";

     

       384
       384
       +
           `S Manpage.s_examples;

     

       385
       385
       +
           `P "Convert waypoints to track:";

     

       386
       386
       +
           `Pre "  mlgpx convert waypoints.gpx track.gpx";

     

       387
       387
       +
           `P "Convert with custom track name and preserve original waypoints:";

     

       388
       388
       +
           `Pre "  mlgpx convert -n \"My Route\" --preserve waypoints.gpx route.gpx";

     

       389
       389
       +
           `P "Sort waypoints by timestamp before conversion:";

     

       390
       390
       +
           `Pre "  mlgpx convert --sort-time waypoints.gpx sorted_track.gpx";

     

       391
       391
       +
         ] in

     

       392
       392
       +
         let term = Term.(const convert_waypoints_to_trackset $ input_file_arg $ output_file_arg 

     

       393
       393
       +
                          $ track_name_opt $ track_description_opt $ sort_by_time_flag 

     

       394
       394
       +
                          $ sort_by_name_flag $ preserve_waypoints_flag $ verbose_flag

     

       395
       395
       +
                          $ Fmt_cli.style_renderer ()) in

     

       396
       396
       +
         Cmd.v (Cmd.info "convert" ~doc ~man) term

     

       397
       397
       +
       

     

       398
       398
       +
       let info_cmd =

     

       399
       399
       +
         let doc = "Display information about a GPX file" in

     

       400
       400
       +
         let man = [

     

       401
       401
       +
           `S Manpage.s_description;

     

       402
       402
       +
           `P "Analyze and display detailed information about a GPX file including \

     

       403
       403
       +
               statistics, content summary, and validation results.";

     

       404
       404
       +
           `P "This command is useful for understanding the structure and content \

     

       405
       405
       +
               of GPX files before processing them.";

     

       406
       406
       +
           `S Manpage.s_examples;

     

       407
       407
       +
           `P "Show basic information:";

     

       408
       408
       +
           `Pre "  mlgpx info file.gpx";

     

       409
       409
       +
           `P "Show detailed information with waypoint details:";

     

       410
       410
       +
           `Pre "  mlgpx info -v file.gpx";

     

       411
       411
       +
         ] in

     

       412
       412
       +
         let input_arg = 

     

       413
       413
       +
           let doc = "GPX file to analyze" in

     

       414
       414
       +
           Arg.(required & pos 0 (some non_dir_file) None & info [] ~docv:"FILE" ~doc) in

     

       415
       415
       +
         let term = Term.(const info_command $ input_arg $ verbose_flag 

     

       416
       416
       +
                          $ Fmt_cli.style_renderer ()) in

     

       417
       417
       +
         Cmd.v (Cmd.info "info" ~doc ~man) term

     

       418
       418
       +
       

     

       419
       419
       +
       (* Main CLI *)

     

       420
       420
       +
       let main_cmd =

     

       421
       421
       +
         let doc = "mlgpx - GPX file manipulation toolkit" in

     

       422
       422
       +
         let man = [

     

       423
       423
       +
           `S Manpage.s_description;

     

       424
       424
       +
           `P "mlgpx is a command-line toolkit for working with GPX (GPS Exchange Format) \

     

       425
       425
       +
               files. It provides tools for converting, analyzing, and manipulating GPS data.";

     

       426
       426
       +
           `S Manpage.s_commands;

     

       427
       427
       +
           `P "Available commands:";

     

       428
       428
       +
           `P "$(b,convert) - Convert waypoints to trackset";

     

       429
       429
       +
           `P "$(b,info) - Display GPX file information";

     

       430
       430
       +
           `S Manpage.s_common_options;

     

       431
       431
       +
           `P "$(b,--verbose), $(b,-v) - Enable verbose output";

     

       432
       432
       +
           `P "$(b,--color)={auto|always|never} - Control ANSI color output";

     

       433
       433
       +
           `P "$(b,--help) - Show command help";

     

       434
       434
       +
           `S Manpage.s_examples;

     

       435
       435
       +
           `P "Convert waypoints to track:";

     

       436
       436
       +
           `Pre "  mlgpx convert waypoints.gpx track.gpx";

     

       437
       437
       +
           `P "Analyze a GPX file with colors:";

     

       438
       438
       +
           `Pre "  mlgpx info --verbose --color=always file.gpx";

     

       439
       439
       +
           `P "Convert without colors for scripts:";

     

       440
       440
       +
           `Pre "  mlgpx convert --color=never waypoints.gpx track.gpx";

     

       441
       441
       +
           `S Manpage.s_bugs;

     

       442
       442
       +
           `P "Report bugs at https://github.com/avsm/mlgpx/issues";

     

       443
       443
       +
         ] in

     

       444
       444
       +
         let default_term = Term.(ret (const (`Help (`Pager, None)))) in

     

       445
       445
       +
         Cmd.group (Cmd.info "mlgpx" ~version:"0.1.0" ~doc ~man) ~default:default_term 

     

       446
       446
       +
           [convert_cmd; info_cmd]

     

       447
       447
       +
       

     

       448
       448
       +
       let () = 

     

       449
       449
       +
         Printexc.record_backtrace true;

     

       450
       450
       +
         exit (Cmd.eval main_cmd)

+5 -1

dune-project

···

       1
       1
        
       (lang dune 3.18)

     

       2
       2
        
       

     

       3
       3
       +
       (name mlgpx)

     

       4
       4
       +
       

     

       3
       5
        
       (generate_opam_files true)

     

       4
       6
        
       

     

       5
       7
        
       (package

     

       6
       8
        
        (name mlgpx)

     

       7
       7
       -
        (depends ocaml dune xmlm ptime eio ppx_expect alcotest eio_main cmdliner fmt logs)

     

       9
       9
       +
        (depends ocaml dune xmlm ptime (eio (>= 1.2)) ppx_expect alcotest eio_main cmdliner fmt logs)

     

       8
       10
        
        (synopsis "Library and CLI for parsing and generating GPS Exchange (GPX) formats")

     

       9
       11
        
        (description

     

       10
       12
        
         "mlgpx is a streaming GPX (GPS Exchange Format) library for OCaml. It provides a portable core library using the xmlm streaming XML parser, with a separate Unix layer for file I/O operations. The library supports the complete GPX 1.1 specification including waypoints, routes, tracks, and metadata with strong type safety and validation.")

     

       11
       13
        
        (license ISC)

     

       12
       14
        
        (authors "Anil Madhavapeddy")

     

       13
       15
        
        (homepage "https://tangled.sh/@anil.recoil.org/ocaml-gpx")

     

       16
       16
       +
        (maintainers "Anil Madhavapeddy <anil@recoil.org>")

     

       17
       17
       +
        (bug_reports https://tangled.sh/@anil.recoil.org/ocaml-gpx/issues)

     

       14
       18
        
        (maintenance_intent "(latest)")

     

       15
       19
        
       )

example_output.gpx

This is a binary file and will not be displayed.

-5

examples/dune

···

       2
       2
        
        (public_name simple_gpx)

     

       3
       3
        
        (name simple_gpx)

     

       4
       4
        
        (libraries gpx xmlm))

     

       5
       5
       -
       

     

       6
       6
       -
       (executable

     

       7
       7
       -
        (public_name effects_example)

     

       8
       8
       -
        (name effects_example)

     

       9
       9
       -
        (libraries gpx xmlm))

-117

examples/effects_example.ml

···

       1
       1
       -
       (** Simple GPX example demonstrating basic functionality **)

     

       2
       2
       -
       

     

       3
       3
       -
       open Gpx

     

       4
       4
       -
       

     

       5
       5
       -
       let () =

     

       6
       6
       -
         Printf.printf "=== Simple GPX Example ===\n\n";

     

       7
       7
       -
         

     

       8
       8
       -
         try

     

       9
       9
       -
           (* Create some GPS coordinates *)

     

       10
       10
       -
           let lat1 = Coordinate.latitude 37.7749 |> Result.get_ok in

     

       11
       11
       -
           let lon1 = Coordinate.longitude (-122.4194) |> Result.get_ok in

     

       12
       12
       -
           let lat2 = Coordinate.latitude 37.7849 |> Result.get_ok in

     

       13
       13
       -
           let lon2 = Coordinate.longitude (-122.4094) |> Result.get_ok in

     

       14
       14
       -
           

     

       15
       15
       -
           (* Create waypoints *)

     

       16
       16
       -
           let waypoint1 = Waypoint.make lat1 lon1 in

     

       17
       17
       -
           let waypoint1 = Waypoint.with_name waypoint1 "San Francisco" in

     

       18
       18
       -
           let waypoint2 = Waypoint.make lat2 lon2 in

     

       19
       19
       -
           let waypoint2 = Waypoint.with_name waypoint2 "Near SF" in

     

       20
       20
       -
           

     

       21
       21
       -
           (* Create a simple track from coordinates *)

     

       22
       22
       -
           let track = Track.make ~name:"SF Walk" in

     

       23
       23
       -
           let track_segment = Track.Segment.empty in

     

       24
       24
       -
           let coords = [

     

       25
       25
       -
             (37.7749, -122.4194);

     

       26
       26
       -
             (37.7759, -122.4184);

     

       27
       27
       -
             (37.7769, -122.4174);

     

       28
       28
       -
             (37.7779, -122.4164);

     

       29
       29
       -
           ] in

     

       30
       30
       -
           let track_segment = List.fold_left (fun seg (lat_f, lon_f) ->

     

       31
       31
       -
             match Coordinate.latitude lat_f, Coordinate.longitude lon_f with

     

       32
       32
       -
             | Ok lat, Ok lon ->

     

       33
       33
       -
                 let pt = Waypoint.make lat lon in

     

       34
       34
       -
                 Track.Segment.add_point seg pt

     

       35
       35
       -
             | _ -> seg

     

       36
       36
       -
           ) track_segment coords in

     

       37
       37
       -
           let track = Track.add_segment track track_segment in

     

       38
       38
       -
           

     

       39
       39
       -
           (* Create a route *)

     

       40
       40
       -
           let route = Route.make ~name:"SF Route" in

     

       41
       41
       -
           let route_coords = [

     

       42
       42
       -
             (37.7749, -122.4194);

     

       43
       43
       -
             (37.7849, -122.4094);

     

       44
       44
       -
           ] in

     

       45
       45
       -
           let route = List.fold_left (fun r (lat_f, lon_f) ->

     

       46
       46
       -
             match Coordinate.latitude lat_f, Coordinate.longitude lon_f with

     

       47
       47
       -
             | Ok lat, Ok lon ->

     

       48
       48
       -
                 let pt = Waypoint.make lat lon in

     

       49
       49
       -
                 Route.add_point r pt

     

       50
       50
       -
             | _ -> r

     

       51
       51
       -
           ) route route_coords in

     

       52
       52
       -
           

     

       53
       53
       -
           (* Create GPX document with all elements *)

     

       54
       54
       -
           let gpx = Gpx_doc.empty ~creator:"simple-example" in

     

       55
       55
       -
           let gpx = Gpx_doc.add_waypoint gpx waypoint1 in

     

       56
       56
       -
           let gpx = Gpx_doc.add_waypoint gpx waypoint2 in

     

       57
       57
       -
           let gpx = Gpx_doc.add_track gpx track in

     

       58
       58
       -
           let gpx = Gpx_doc.add_route gpx route in

     

       59
       59
       -
           

     

       60
       60
       -
           Printf.printf "Created GPX document with:\n";

     

       61
       61
       -
           Printf.printf "  Waypoints: %d\n" (List.length (Gpx_doc.get_waypoints gpx));

     

       62
       62
       -
           Printf.printf "  Tracks: %d\n" (List.length (Gpx_doc.get_tracks gpx));

     

       63
       63
       -
           Printf.printf "  Routes: %d\n" (List.length (Gpx_doc.get_routes gpx));

     

       64
       64
       -
           Printf.printf "\n";

     

       65
       65
       -
           

     

       66
       66
       -
           (* Write to file with validation *)

     

       67
       67
       -
           let out_chan = open_out "example_output.gpx" in

     

       68
       68
       -
           let dest = (`Channel out_chan) in

     

       69
       69
       -
           (match write ~validate:true dest gpx with

     

       70
       70
       -
            | Ok () ->

     

       71
       71
       -
                close_out out_chan;

     

       72
       72
       -
                Printf.printf "Wrote GPX to example_output.gpx\n"

     

       73
       73
       -
            | Error e ->

     

       74
       74
       -
                close_out out_chan;

     

       75
       75
       -
                Printf.eprintf "Error writing GPX: %s\n" (Error.to_string e)

     

       76
       76
       -
           );

     

       77
       77
       -
           

     

       78
       78
       -
           (* Read it back and verify *)

     

       79
       79
       -
           let in_chan = open_in "example_output.gpx" in

     

       80
       80
       -
           let input = Xmlm.make_input (`Channel in_chan) in

     

       81
       81
       -
           (match parse ~validate:true input with

     

       82
       82
       -
            | Ok gpx2 ->

     

       83
       83
       -
                close_in in_chan;

     

       84
       84
       -
                let waypoints = Gpx_doc.get_waypoints gpx2 in

     

       85
       85
       -
                let tracks = Gpx_doc.get_tracks gpx2 in

     

       86
       86
       -
                let routes = Gpx_doc.get_routes gpx2 in

     

       87
       87
       -
                Printf.printf "Read back GPX document with %d waypoints, %d tracks, %d routes\n" 

     

       88
       88
       -
                  (List.length waypoints) (List.length tracks) (List.length routes);

     

       89
       89
       -
                

     

       90
       90
       -
                (* Extract coordinates from track *)

     

       91
       91
       -
                (match tracks with

     

       92
       92
       -
                 | track :: _ ->

     

       93
       93
       -
                     let segments = Track.get_segments track in

     

       94
       94
       -
                     (match segments with

     

       95
       95
       -
                      | seg :: _ ->

     

       96
       96
       -
                          let points = Track.Segment.get_points seg in

     

       97
       97
       -
                          Printf.printf "Track coordinates: %d points\n" (List.length points);

     

       98
       98
       -
                          List.iteri (fun i pt ->

     

       99
       99
       -
                            let lat = Coordinate.latitude_to_float (Waypoint.get_lat pt) in

     

       100
       100
       -
                            let lon = Coordinate.longitude_to_float (Waypoint.get_lon pt) in

     

       101
       101
       -
                            Printf.printf "  Point %d: %.4f, %.4f\n" i lat lon

     

       102
       102
       -
                          ) points

     

       103
       103
       -
                      | [] -> Printf.printf "No track segments found\n")

     

       104
       104
       -
                 | [] -> Printf.printf "No tracks found\n")

     

       105
       105
       -
            | Error e ->

     

       106
       106
       -
                close_in in_chan;

     

       107
       107
       -
                Printf.eprintf "Error reading back GPX: %s\n" (Error.to_string e));

     

       108
       108
       -
           

     

       109
       109
       -
           Printf.printf "\nExample completed successfully!\n"

     

       110
       110
       -
           

     

       111
       111
       -
         with

     

       112
       112
       -
         | Gpx_error err ->

     

       113
       113
       -
             Printf.eprintf "GPX Error: %s\n" (Error.to_string err);

     

       114
       114
       -
             exit 1

     

       115
       115
       -
         | exn ->

     

       116
       116
       -
             Printf.eprintf "Unexpected error: %s\n" (Printexc.to_string exn);

     

       117
       117
       -
             exit 1

+9 -12

examples/simple_gpx.ml

···

       17
       17
        
         match result with

     

       18
       18
        
         | Ok (lat, lon) ->

     

       19
       19
        
           let wpt = Waypoint.make lat lon in

     

       20
       20
       -
           let wpt = Waypoint.with_name wpt "San Francisco" in

     

       21
       21
       -
           let wpt = Waypoint.with_description wpt "Golden Gate Bridge area" in

     

       22
       22
       -
           Printf.printf "✓ Created waypoint: %s\n" (Option.value (Waypoint.get_name wpt) ~default:"<unnamed>");

     

       20
       20
       +
           let wpt = { wpt with name = Some "San Francisco"; desc = Some "Golden Gate Bridge area" } in

     

       21
       21
       +
           Printf.printf "✓ Created waypoint: %s\n" (Option.value (Waypoint.name wpt) ~default:"<unnamed>");

     

       23
       22
        
           

     

       24
       23
        
           (* Create GPX document *)

     

       25
       25
       -
           let gpx = Gpx_doc.empty ~creator:"mlgpx direct API example" in

     

       26
       26
       -
           let gpx = Gpx_doc.add_waypoint gpx wpt in

     

       24
       24
       +
           let gpx = Doc.empty ~creator:"mlgpx direct API example" in

     

       25
       25
       +
           let gpx = Doc.add_waypoint gpx wpt in

     

       27
       26
        
           

     

       28
       27
        
           (* Add metadata *)

     

       29
       28
        
           let metadata = Metadata.empty in

     

       30
       30
       -
           let metadata = Metadata.with_name metadata "Example GPX File" in

     

       31
       31
       -
           let metadata = Metadata.with_description metadata "Demonstration of mlgpx library capabilities" in

     

       32
       32
       -
           let gpx = Gpx_doc.with_metadata gpx metadata in

     

       29
       29
       +
           let metadata = { metadata with name = Some "Example GPX File"; desc = Some "Demonstration of mlgpx library capabilities" } in

     

       30
       30
       +
           let gpx = { gpx with metadata = Some metadata } in

     

       33
       31
        
           

     

       34
       32
        
           (* Create a simple track with points *)

     

       35
       33
        
           let track = Track.make ~name:"Example Track" in

     

       36
       36
       -
           let track = Track.with_comment track "Sample GPS track" in

     

       37
       37
       -
           let track = Track.with_description track "Demonstrates track creation" in

     

       34
       34
       +
           let track = { track with cmt = Some "Sample GPS track"; desc = Some "Demonstrates track creation" } in

     

       38
       35
        
           

     

       39
       36
        
           (* Create track segment with points *)

     

       40
       37
        
           let track_segment = Track.Segment.empty in

     
···

       53
       50
        
             ) track_segment points in

     

       54
       51
        
           

     

       55
       52
        
           let track = Track.add_segment track track_segment in

     

       56
       56
       -
           let gpx = Gpx_doc.add_track gpx track in

     

       53
       53
       +
           let gpx = Doc.add_track gpx track in

     

       57
       54
        
           

     

       58
       55
        
           Printf.printf "✓ Created track\n";

     

       59
       56
        
           

     
···

       88
       85
        
                    Printf.printf "✓ Round-trip validation: %s\n" 

     

       89
       86
        
                      (if validation2.is_valid then "PASSED" else "FAILED");

     

       90
       87
        
                    Printf.printf "  Waypoints: %d, Tracks: %d\n"

     

       91
       91
       -
                      (List.length (Gpx_doc.get_waypoints gpx2)) (List.length (Gpx_doc.get_tracks gpx2))

     

       88
       88
       +
                      (List.length (Doc.waypoints gpx2)) (List.length (Doc.tracks gpx2))

     

       92
       89
        
                  | Error e ->

     

       93
       90
        
                    Printf.printf "✗ Error reading back: %s\n" (Error.to_string e)

     

       94
       91
        
                 )

+2 -2

lib/gpx/coordinate.ml

···

       39
       39
        
         | Error e, _ | _, Error e -> Error e

     

       40
       40
        
       

     

       41
       41
        
       (** Extract components *)

     

       42
       42
       -
       let get_lat t = t.lat

     

       43
       43
       -
       let get_lon t = t.lon

     

       42
       42
       +
       let lat t = t.lat

     

       43
       43
       +
       let lon t = t.lon

     

       44
       44
        
       let to_floats t = (latitude_to_float t.lat, longitude_to_float t.lon)

     

       45
       45
        
       

     

       46
       46
        
       (** Compare coordinates *)

+8 -8

lib/gpx/coordinate.mli

···

       1
       1
        
       (** Geographic coordinate types with validation *)

     

       2
       2
        
       

     

       3
       3
       -
       (** Private coordinate types with validation constraints *)

     

       3
       3
       +
       (** Coordinate types with validation constraints *)

     

       4
       4
        
       type latitude = private float

     

       5
       5
        
       type longitude = private float  

     

       6
       6
        
       type degrees = private float

     

       7
       7
        
       

     

       8
       8
       -
       (** Coordinate pair - main type for this module *)

     

       8
       8
       +
       (** Coordinate pair *)

     

       9
       9
        
       type t = {

     

       10
       10
        
         lat : latitude;

     

       11
       11
        
         lon : longitude;

     

       12
       12
        
       }

     

       13
       13
        
       

     

       14
       14
       -
       (** {2 Smart Constructors} *)

     

       14
       14
       +
       (** {2 Constructors} *)

     

       15
       15
        
       

     

       16
       16
        
       (** Create validated latitude.

     

       17
       17
        
           @param f Latitude in degrees (-90.0 to 90.0)

     
···

       39
       39
        
       (** Convert degrees to float *)

     

       40
       40
        
       val degrees_to_float : degrees -> float

     

       41
       41
        
       

     

       42
       42
       -
       (** {2 Coordinate Operations} *)

     

       42
       42
       +
       (** {2 Operations} *)

     

       43
       43
        
       

     

       44
       44
        
       (** Create coordinate pair from validated components *)

     

       45
       45
        
       val make : latitude -> longitude -> t

     
···

       48
       48
        
       val make_from_floats : float -> float -> (t, string) result

     

       49
       49
        
       

     

       50
       50
        
       (** Extract latitude component *)

     

       51
       51
       -
       val get_lat : t -> latitude

     

       51
       51
       +
       val lat : t -> latitude

     

       52
       52
        
       

     

       53
       53
        
       (** Extract longitude component *)

     

       54
       54
       -
       val get_lon : t -> longitude

     

       54
       54
       +
       val lon : t -> longitude

     

       55
       55
        
       

     

       56
       56
        
       (** Convert coordinate to float pair *)

     

       57
       57
        
       val to_floats : t -> float * float

     

       58
       58
        
       

     

       59
       59
       -
       (** {2 Comparison and Utilities} *)

     

       59
       59
       +
       (** {2 Comparison and Printers} *)

     

       60
       60
        
       

     

       61
       61
        
       (** Compare two coordinates *)

     

       62
       62
        
       val compare : t -> t -> int

     
···

       65
       65
        
       val equal : t -> t -> bool

     

       66
       66
        
       

     

       67
       67
        
       (** Pretty print coordinate *)

     

       68
       68
       -
       val pp : Format.formatter -> t -> unit
     

       68
       68
       +
       val pp : Format.formatter -> t -> unit

+186

lib/gpx/doc.ml

···

       1
       1
       +
       (** Main GPX document type *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** Main GPX document type *)

     

       4
       4
       +
       type t = {

     

       5
       5
       +
         version : string;                    (* GPX version: "1.0" or "1.1" *)

     

       6
       6
       +
         creator : string;                    (* Creating application *)

     

       7
       7
       +
         metadata : Metadata.t option;       (* Document metadata *)

     

       8
       8
       +
         waypoints : Waypoint.t list;        (* Waypoints *)

     

       9
       9
       +
         routes : Route.t list;               (* Routes *)

     

       10
       10
       +
         tracks : Track.t list;               (* Tracks *)

     

       11
       11
       +
         extensions : Extension.t list;       (* Document-level extensions *)

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       (** {2 Document Constructors} *)

     

       15
       15
       +
       

     

       16
       16
       +
       (** Create empty GPX document *)

     

       17
       17
       +
       let empty ~creator = {

     

       18
       18
       +
         version = "1.1";

     

       19
       19
       +
         creator;

     

       20
       20
       +
         metadata = None;

     

       21
       21
       +
         waypoints = [];

     

       22
       22
       +
         routes = [];

     

       23
       23
       +
         tracks = [];

     

       24
       24
       +
         extensions = [];

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       (** Create GPX document with metadata *)

     

       28
       28
       +
       let make ~creator ~metadata = 

     

       29
       29
       +
         { (empty ~creator) with metadata = Some metadata }

     

       30
       30
       +
       

     

       31
       31
       +
       (** {2 Document Properties} *)

     

       32
       32
       +
       

     

       33
       33
       +
       (** Get version *)

     

       34
       34
       +
       let version t = t.version

     

       35
       35
       +
       

     

       36
       36
       +
       (** Get creator *)

     

       37
       37
       +
       let creator t = t.creator

     

       38
       38
       +
       

     

       39
       39
       +
       (** Get metadata *)

     

       40
       40
       +
       let metadata t = t.metadata

     

       41
       41
       +
       

     

       42
       42
       +
       (** Get waypoints *)

     

       43
       43
       +
       let waypoints t = t.waypoints

     

       44
       44
       +
       

     

       45
       45
       +
       (** Get routes *)

     

       46
       46
       +
       let routes t = t.routes

     

       47
       47
       +
       

     

       48
       48
       +
       (** Get tracks *)

     

       49
       49
       +
       let tracks t = t.tracks

     

       50
       50
       +
       

     

       51
       51
       +
       (** Get extensions *)

     

       52
       52
       +
       let extensions t = t.extensions

     

       53
       53
       +
       

     

       54
       54
       +
       (** {2 Document Modification} *)

     

       55
       55
       +
       

     

       56
       56
       +
       (** Update metadata *)

     

       57
       57
       +
       let with_metadata t metadata = { t with metadata = Some metadata }

     

       58
       58
       +
       

     

       59
       59
       +
       (** Add waypoint *)

     

       60
       60
       +
       let add_waypoint t waypoint = { t with waypoints = t.waypoints @ [waypoint] }

     

       61
       61
       +
       

     

       62
       62
       +
       (** Add waypoints *)

     

       63
       63
       +
       let add_waypoints t waypoints = { t with waypoints = t.waypoints @ waypoints }

     

       64
       64
       +
       

     

       65
       65
       +
       (** Add route *)

     

       66
       66
       +
       let add_route t route = { t with routes = t.routes @ [route] }

     

       67
       67
       +
       

     

       68
       68
       +
       (** Add routes *)

     

       69
       69
       +
       let add_routes t routes = { t with routes = t.routes @ routes }

     

       70
       70
       +
       

     

       71
       71
       +
       (** Add track *)

     

       72
       72
       +
       let add_track t track = { t with tracks = t.tracks @ [track] }

     

       73
       73
       +
       

     

       74
       74
       +
       (** Add tracks *)

     

       75
       75
       +
       let add_tracks t tracks = { t with tracks = t.tracks @ tracks }

     

       76
       76
       +
       

     

       77
       77
       +
       (** Add extensions *)

     

       78
       78
       +
       let add_extensions t extensions = { t with extensions = t.extensions @ extensions }

     

       79
       79
       +
       

     

       80
       80
       +
       (** Clear waypoints *)

     

       81
       81
       +
       let clear_waypoints t = { t with waypoints = [] }

     

       82
       82
       +
       

     

       83
       83
       +
       (** Clear routes *)

     

       84
       84
       +
       let clear_routes t = { t with routes = [] }

     

       85
       85
       +
       

     

       86
       86
       +
       (** Clear tracks *)

     

       87
       87
       +
       let clear_tracks t = { t with tracks = [] }

     

       88
       88
       +
       

     

       89
       89
       +
       (** {2 Document Analysis} *)

     

       90
       90
       +
       

     

       91
       91
       +
       (** Count waypoints *)

     

       92
       92
       +
       let waypoint_count t = List.length t.waypoints

     

       93
       93
       +
       

     

       94
       94
       +
       (** Count routes *)

     

       95
       95
       +
       let route_count t = List.length t.routes

     

       96
       96
       +
       

     

       97
       97
       +
       (** Count tracks *)

     

       98
       98
       +
       let track_count t = List.length t.tracks

     

       99
       99
       +
       

     

       100
       100
       +
       (** Count total points *)

     

       101
       101
       +
       let total_points t =

     

       102
       102
       +
         let waypoint_points = List.length t.waypoints in

     

       103
       103
       +
         let route_points = List.fold_left (fun acc route -> 

     

       104
       104
       +
           acc + Route.point_count route) 0 t.routes in

     

       105
       105
       +
         let track_points = List.fold_left (fun acc track -> 

     

       106
       106
       +
           acc + Track.point_count track) 0 t.tracks in

     

       107
       107
       +
         waypoint_points + route_points + track_points

     

       108
       108
       +
       

     

       109
       109
       +
       (** Check if document has elevation data *)

     

       110
       110
       +
       let has_elevation t =

     

       111
       111
       +
         List.exists (fun wpt -> Waypoint.elevation wpt <> None) t.waypoints ||

     

       112
       112
       +
         List.exists (fun route ->

     

       113
       113
       +
           List.exists (fun pt -> Waypoint.elevation pt <> None) (Route.points route)

     

       114
       114
       +
         ) t.routes ||

     

       115
       115
       +
         List.exists (fun track ->

     

       116
       116
       +
           List.exists (fun pt -> Waypoint.elevation pt <> None) (Track.all_points track)

     

       117
       117
       +
         ) t.tracks

     

       118
       118
       +
       

     

       119
       119
       +
       (** Check if document has time data *)

     

       120
       120
       +
       let has_time t =

     

       121
       121
       +
         List.exists (fun wpt -> Waypoint.time wpt <> None) t.waypoints ||

     

       122
       122
       +
         List.exists (fun route ->

     

       123
       123
       +
           List.exists (fun pt -> Waypoint.time pt <> None) (Route.points route)

     

       124
       124
       +
         ) t.routes ||

     

       125
       125
       +
         List.exists (fun track ->

     

       126
       126
       +
           List.exists (fun pt -> Waypoint.time pt <> None) (Track.all_points track)

     

       127
       127
       +
         ) t.tracks

     

       128
       128
       +
       

     

       129
       129
       +
       (** Check if document is empty *)

     

       130
       130
       +
       let is_empty t = 

     

       131
       131
       +
         waypoint_count t = 0 && route_count t = 0 && track_count t = 0

     

       132
       132
       +
       

     

       133
       133
       +
       (** Get statistics *)

     

       134
       134
       +
       type stats = {

     

       135
       135
       +
         waypoint_count : int;

     

       136
       136
       +
         route_count : int;

     

       137
       137
       +
         track_count : int;

     

       138
       138
       +
         total_points : int;

     

       139
       139
       +
         has_elevation : bool;

     

       140
       140
       +
         has_time : bool;

     

       141
       141
       +
       }

     

       142
       142
       +
       

     

       143
       143
       +
       let stats t = {

     

       144
       144
       +
         waypoint_count = waypoint_count t;

     

       145
       145
       +
         route_count = route_count t;

     

       146
       146
       +
         track_count = track_count t;

     

       147
       147
       +
         total_points = total_points t;

     

       148
       148
       +
         has_elevation = has_elevation t;

     

       149
       149
       +
         has_time = has_time t;

     

       150
       150
       +
       }

     

       151
       151
       +
       

     

       152
       152
       +
       (** Pretty print statistics *)

     

       153
       153
       +
       let pp_stats ppf t =

     

       154
       154
       +
         let s = stats t in

     

       155
       155
       +
         Format.fprintf ppf "@[<v>GPX Statistics:@,  Waypoints: %d@,  Routes: %d@,  Tracks: %d@,  Total points: %d@,  Has elevation data: %s@,  Has time data: %s@]"

     

       156
       156
       +
           s.waypoint_count s.route_count s.track_count s.total_points

     

       157
       157
       +
           (if s.has_elevation then "yes" else "no")

     

       158
       158
       +
           (if s.has_time then "yes" else "no")

     

       159
       159
       +
       

     

       160
       160
       +
       (** {2 Comparison and Utilities} *)

     

       161
       161
       +
       

     

       162
       162
       +
       (** Compare documents *)

     

       163
       163
       +
       let compare t1 t2 =

     

       164
       164
       +
         let version_cmp = String.compare t1.version t2.version in

     

       165
       165
       +
         if version_cmp <> 0 then version_cmp

     

       166
       166
       +
         else

     

       167
       167
       +
           let creator_cmp = String.compare t1.creator t2.creator in

     

       168
       168
       +
           if creator_cmp <> 0 then creator_cmp

     

       169
       169
       +
           else

     

       170
       170
       +
             let waypoints_cmp = List.compare Waypoint.compare t1.waypoints t2.waypoints in

     

       171
       171
       +
             if waypoints_cmp <> 0 then waypoints_cmp

     

       172
       172
       +
             else

     

       173
       173
       +
               let routes_cmp = List.compare Route.compare t1.routes t2.routes in

     

       174
       174
       +
               if routes_cmp <> 0 then routes_cmp

     

       175
       175
       +
               else List.compare Track.compare t1.tracks t2.tracks

     

       176
       176
       +
       

     

       177
       177
       +
       (** Test document equality *)

     

       178
       178
       +
       let equal t1 t2 = compare t1 t2 = 0

     

       179
       179
       +
       

     

       180
       180
       +
       (** Pretty print document *)

     

       181
       181
       +
       let pp ppf t =

     

       182
       182
       +
         let stats = stats t in

     

       183
       183
       +
         Format.fprintf ppf "GPX v%s by %s (%d wpt, %d routes, %d tracks, %d total points)"

     

       184
       184
       +
           t.version t.creator 

     

       185
       185
       +
           stats.waypoint_count stats.route_count stats.track_count stats.total_points

     

       186
       186
       +

+128

lib/gpx/doc.mli

···

       1
       1
       +
       (** Main GPX document type *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** Main GPX document type *)

     

       4
       4
       +
       type t = {

     

       5
       5
       +
         version : string;                    (* GPX version: "1.0" or "1.1" *)

     

       6
       6
       +
         creator : string;                    (* Creating application *)

     

       7
       7
       +
         metadata : Metadata.t option;       (* Document metadata *)

     

       8
       8
       +
         waypoints : Waypoint.t list;        (* Waypoints *)

     

       9
       9
       +
         routes : Route.t list;               (* Routes *)

     

       10
       10
       +
         tracks : Track.t list;               (* Tracks *)

     

       11
       11
       +
         extensions : Extension.t list;       (* Document-level extensions *)

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       (** Document statistics *)

     

       15
       15
       +
       type stats = {

     

       16
       16
       +
         waypoint_count : int;

     

       17
       17
       +
         route_count : int;

     

       18
       18
       +
         track_count : int;

     

       19
       19
       +
         total_points : int;

     

       20
       20
       +
         has_elevation : bool;

     

       21
       21
       +
         has_time : bool;

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       (** {2 Document Constructors} *)

     

       25
       25
       +
       

     

       26
       26
       +
       (** Create empty GPX document *)

     

       27
       27
       +
       val empty : creator:string -> t

     

       28
       28
       +
       

     

       29
       29
       +
       (** Create GPX document with metadata *)

     

       30
       30
       +
       val make : creator:string -> metadata:Metadata.t -> t

     

       31
       31
       +
       

     

       32
       32
       +
       (** {2 Document Properties} *)

     

       33
       33
       +
       

     

       34
       34
       +
       (** Get version *)

     

       35
       35
       +
       val version : t -> string

     

       36
       36
       +
       

     

       37
       37
       +
       (** Get creator *)

     

       38
       38
       +
       val creator : t -> string

     

       39
       39
       +
       

     

       40
       40
       +
       (** Get metadata *)

     

       41
       41
       +
       val metadata : t -> Metadata.t option

     

       42
       42
       +
       

     

       43
       43
       +
       (** Get waypoints *)

     

       44
       44
       +
       val waypoints : t -> Waypoint.t list

     

       45
       45
       +
       

     

       46
       46
       +
       (** Get routes *)

     

       47
       47
       +
       val routes : t -> Route.t list

     

       48
       48
       +
       

     

       49
       49
       +
       (** Get tracks *)

     

       50
       50
       +
       val tracks : t -> Track.t list

     

       51
       51
       +
       

     

       52
       52
       +
       (** Get extensions *)

     

       53
       53
       +
       val extensions : t -> Extension.t list

     

       54
       54
       +
       

     

       55
       55
       +
       (** {2 Document Modification} *)

     

       56
       56
       +
       

     

       57
       57
       +
       (** Update metadata *)

     

       58
       58
       +
       val with_metadata : t -> Metadata.t -> t

     

       59
       59
       +
       

     

       60
       60
       +
       (** Add waypoint *)

     

       61
       61
       +
       val add_waypoint : t -> Waypoint.t -> t

     

       62
       62
       +
       

     

       63
       63
       +
       (** Add waypoints *)

     

       64
       64
       +
       val add_waypoints : t -> Waypoint.t list -> t

     

       65
       65
       +
       

     

       66
       66
       +
       (** Add route *)

     

       67
       67
       +
       val add_route : t -> Route.t -> t

     

       68
       68
       +
       

     

       69
       69
       +
       (** Add routes *)

     

       70
       70
       +
       val add_routes : t -> Route.t list -> t

     

       71
       71
       +
       

     

       72
       72
       +
       (** Add track *)

     

       73
       73
       +
       val add_track : t -> Track.t -> t

     

       74
       74
       +
       

     

       75
       75
       +
       (** Add tracks *)

     

       76
       76
       +
       val add_tracks : t -> Track.t list -> t

     

       77
       77
       +
       

     

       78
       78
       +
       (** Add extensions *)

     

       79
       79
       +
       val add_extensions : t -> Extension.t list -> t

     

       80
       80
       +
       

     

       81
       81
       +
       (** Clear waypoints *)

     

       82
       82
       +
       val clear_waypoints : t -> t

     

       83
       83
       +
       

     

       84
       84
       +
       (** Clear routes *)

     

       85
       85
       +
       val clear_routes : t -> t

     

       86
       86
       +
       

     

       87
       87
       +
       (** Clear tracks *)

     

       88
       88
       +
       val clear_tracks : t -> t

     

       89
       89
       +
       

     

       90
       90
       +
       (** {2 Document Analysis} *)

     

       91
       91
       +
       

     

       92
       92
       +
       (** Count waypoints *)

     

       93
       93
       +
       val waypoint_count : t -> int

     

       94
       94
       +
       

     

       95
       95
       +
       (** Count routes *)

     

       96
       96
       +
       val route_count : t -> int

     

       97
       97
       +
       

     

       98
       98
       +
       (** Count tracks *)

     

       99
       99
       +
       val track_count : t -> int

     

       100
       100
       +
       

     

       101
       101
       +
       (** Count total points *)

     

       102
       102
       +
       val total_points : t -> int

     

       103
       103
       +
       

     

       104
       104
       +
       (** Check if document has elevation data *)

     

       105
       105
       +
       val has_elevation : t -> bool

     

       106
       106
       +
       

     

       107
       107
       +
       (** Check if document has time data *)

     

       108
       108
       +
       val has_time : t -> bool

     

       109
       109
       +
       

     

       110
       110
       +
       (** Check if document is empty *)

     

       111
       111
       +
       val is_empty : t -> bool

     

       112
       112
       +
       

     

       113
       113
       +
       (** Get document statistics *)

     

       114
       114
       +
       val stats : t -> stats

     

       115
       115
       +
       

     

       116
       116
       +
       (** Pretty print statistics *)

     

       117
       117
       +
       val pp_stats : Format.formatter -> t -> unit

     

       118
       118
       +
       

     

       119
       119
       +
       (** {2 Comparison and Utilities} *)

     

       120
       120
       +
       

     

       121
       121
       +
       (** Compare documents *)

     

       122
       122
       +
       val compare : t -> t -> int

     

       123
       123
       +
       

     

       124
       124
       +
       (** Test document equality *)

     

       125
       125
       +
       val equal : t -> t -> bool

     

       126
       126
       +
       

     

       127
       127
       +
       (** Pretty print document *)

     

       128
       128
       +
       val pp : Format.formatter -> t -> unit

+14 -1

lib/gpx/dune

···

       2
       2
        
        (public_name mlgpx.core)

     

       3
       3
        
        (name gpx)

     

       4
       4
        
        (libraries xmlm ptime)

     

       5
       5
       -
        (modules gpx parser writer validate coordinate link extension waypoint metadata route track error gpx_doc))
     

       5
       5
       +
        (modules

     

       6
       6
       +
         gpx

     

       7
       7
       +
         parser

     

       8
       8
       +
         writer

     

       9
       9
       +
         validate

     

       10
       10
       +
         coordinate

     

       11
       11
       +
         link

     

       12
       12
       +
         extension

     

       13
       13
       +
         waypoint

     

       14
       14
       +
         metadata

     

       15
       15
       +
         route

     

       16
       16
       +
         track

     

       17
       17
       +
         error

     

       18
       18
       +
         doc))

+8 -8

lib/gpx/extension.ml

···

       17
       17
        
       (** {2 Extension Operations} *)

     

       18
       18
        
       

     

       19
       19
        
       (** Create extension with flexible content *)

     

       20
       20
       -
       let make ~namespace ~name ~attributes ~content () =

     

       20
       20
       +
       let make ?namespace ~name ~attributes ~content () =

     

       21
       21
        
         { namespace; name; attributes; content }

     

       22
       22
        
       

     

       23
       23
        
       (** Create an extension with text content *)

     
···

       33
       33
        
         { namespace; name; attributes; content = Mixed (text, elements) }

     

       34
       34
        
       

     

       35
       35
        
       (** Get extension name *)

     

       36
       36
       -
       let get_name t = t.name

     

       36
       36
       +
       let name t = t.name

     

       37
       37
        
       

     

       38
       38
        
       (** Get optional namespace *)

     

       39
       39
       -
       let get_namespace t = t.namespace

     

       39
       39
       +
       let namespace t = t.namespace

     

       40
       40
        
       

     

       41
       41
        
       (** Get attributes *)

     

       42
       42
       -
       let get_attributes t = t.attributes

     

       42
       42
       +
       let attributes t = t.attributes

     

       43
       43
        
       

     

       44
       44
        
       (** Get content *)

     

       45
       45
       -
       let get_content t = t.content

     

       45
       45
       +
       let content t = t.content

     

       46
       46
        
       

     

       47
       47
        
       (** Create text content *)

     

       48
       48
        
       let text_content text = Text text

     
···

       135
       135
        
       let is_mixed_content = function Mixed _ -> true | _ -> false

     

       136
       136
        
       

     

       137
       137
        
       (** Extract text content *)

     

       138
       138
       -
       let get_text_content = function Text s -> Some s | _ -> None

     

       138
       138
       +
       let text_content_extract = function Text s -> Some s | _ -> None

     

       139
       139
        
       

     

       140
       140
        
       (** Extract element content *)

     

       141
       141
       -
       let get_elements_content = function Elements e -> Some e | _ -> None

     

       141
       141
       +
       let elements_content_extract = function Elements e -> Some e | _ -> None

     

       142
       142
        
       

     

       143
       143
        
       (** Extract mixed content *)

     

       144
       144
       -
       let get_mixed_content = function Mixed (s, e) -> Some (s, e) | _ -> None
     

       144
       144
       +
       let mixed_content_extract = function Mixed (s, e) -> Some (s, e) | _ -> None

+8 -8

lib/gpx/extension.mli

···

       17
       17
        
       (** {2 Extension Constructors} *)

     

       18
       18
        
       

     

       19
       19
        
       (** Create extension with flexible content *)

     

       20
       20
       -
       val make : namespace:string option -> name:string -> attributes:(string * string) list -> content:content -> unit -> t

     

       20
       20
       +
       val make : ?namespace:string -> name:string -> attributes:(string * string) list -> content:content -> unit -> t

     

       21
       21
        
       

     

       22
       22
        
       (** Create an extension with text content *)

     

       23
       23
        
       val make_text : name:string -> ?namespace:string -> ?attributes:(string * string) list -> string -> t

     
···

       31
       31
        
       (** {2 Extension Operations} *)

     

       32
       32
        
       

     

       33
       33
        
       (** Get extension name *)

     

       34
       34
       -
       val get_name : t -> string

     

       34
       34
       +
       val name : t -> string

     

       35
       35
        
       

     

       36
       36
        
       (** Get optional namespace *)

     

       37
       37
       -
       val get_namespace : t -> string option

     

       37
       37
       +
       val namespace : t -> string option

     

       38
       38
        
       

     

       39
       39
        
       (** Get attributes *)

     

       40
       40
       -
       val get_attributes : t -> (string * string) list

     

       40
       40
       +
       val attributes : t -> (string * string) list

     

       41
       41
        
       

     

       42
       42
        
       (** Get content *)

     

       43
       43
       -
       val get_content : t -> content

     

       43
       43
       +
       val content : t -> content

     

       44
       44
        
       

     

       45
       45
        
       (** Find attribute value by name *)

     

       46
       46
        
       val find_attribute : string -> t -> string option

     
···

       78
       78
        
       val is_mixed_content : content -> bool

     

       79
       79
        
       

     

       80
       80
        
       (** Extract text content *)

     

       81
       81
       -
       val get_text_content : content -> string option

     

       81
       81
       +
       val text_content_extract : content -> string option

     

       82
       82
        
       

     

       83
       83
        
       (** Extract element content *)

     

       84
       84
       -
       val get_elements_content : content -> t list option

     

       84
       84
       +
       val elements_content_extract : content -> t list option

     

       85
       85
        
       

     

       86
       86
        
       (** Extract mixed content *)

     

       87
       87
       -
       val get_mixed_content : content -> (string * t list) option
     

       87
       87
       +
       val mixed_content_extract : content -> (string * t list) option

+6 -6

lib/gpx/gpx.ml

···

       27
       27
        
       module Error = Error

     

       28
       28
        
       

     

       29
       29
        
       (** Main GPX document type *)

     

       30
       30
       -
       module Gpx_doc = Gpx_doc

     

       30
       30
       +
       module Doc = Doc

     

       31
       31
        
       

     

       32
       32
        
       (** {1 Main Document Type} *)

     

       33
       33
        
       

     

       34
       34
        
       (** Main GPX document type *)

     

       35
       35
       -
       type t = Gpx_doc.t

     

       35
       35
       +
       type t = Doc.t

     

       36
       36
        
       

     

       37
       37
        
       (** {1 Error Handling} *)

     

       38
       38
        
       

     
···

       80
       80
        
       let is_valid = Validate.is_valid

     

       81
       81
        
       

     

       82
       82
        
       (** Get only error messages *)

     

       83
       83
       -
       let get_errors = Validate.get_errors

     

       83
       83
       +
       let errors = Validate.errors

     

       84
       84
        
       

     

       85
       85
        
       (** Get only warning messages *)

     

       86
       86
       -
       let get_warnings = Validate.get_warnings

     

       86
       86
       +
       let warnings = Validate.warnings

     

       87
       87
        
       

     

       88
       88
        
       (** Format validation issue for display *)

     

       89
       89
        
       let format_issue = Validate.format_issue

     
···

       91
       91
        
       (** {1 Constructors and Utilities} *)

     

       92
       92
        
       

     

       93
       93
        
       (** Create new GPX document *)

     

       94
       94
       -
       let make_gpx ~creator = Gpx_doc.empty ~creator

     

       94
       94
       +
       let make_gpx ~creator = Doc.empty ~creator

     

       95
       95
        
       

     

       96
       96
        
       (** Create empty GPX document *)

     

       97
       97
       -
       let empty ~creator = Gpx_doc.empty ~creator
     

       97
       97
       +
       let empty ~creator = Doc.empty ~creator

+443 -54

lib/gpx/gpx.mli

···

       1
       1
       -
       (** OCaml library for reading and writing GPX (GPS Exchange Format) files 

     

       1
       1
       +
       (** OCaml library for reading and writing GPX (GPS Exchange Format) files.

     

       2
       2
       +
           

     

       3
       3
       +
           {1 Overview}

     

       4
       4
       +
           

     

       5
       5
       +
           GPX (GPS Exchange Format) is an XML-based format for GPS data interchange,

     

       6
       6
       +
           standardized by {{:https://www.topografix.com/gpx.asp}Topografix}. This library

     

       7
       7
       +
           provides a complete implementation of the GPX 1.1 specification with strong

     

       8
       8
       +
           type safety and validation.

     

       9
       9
       +
           

     

       10
       10
       +
           GPX files can contain three main types of GPS data:

     

       11
       11
       +
           - {b Waypoints}: Individual points of interest with coordinates

     

       12
       12
       +
           - {b Routes}: Ordered sequences of waypoints representing a planned path

     

       13
       13
       +
           - {b Tracks}: Recorded GPS traces, typically from actual journeys

     

       14
       14
       +
           

     

       15
       15
       +
           All coordinates in GPX use the WGS84 datum (World Geodetic System 1984),

     

       16
       16
       +
           the same coordinate system used by GPS satellites. Coordinates are expressed

     

       17
       17
       +
           as decimal degrees, with elevations in meters above mean sea level.

     

       18
       18
       +
           

     

       19
       19
       +
           {2 Quick Start Example}

     

       20
       20
       +
           

     

       21
       21
       +
           {[

     

       22
       22
       +
             open Gpx

     

       23
       23
       +
             

     

       24
       24
       +
             (* Create coordinates *)

     

       25
       25
       +
             let lat = Coordinate.latitude 37.7749 |> Result.get_ok in

     

       26
       26
       +
             let lon = Coordinate.longitude (-122.4194) |> Result.get_ok in

     

       27
       27
       +
             

     

       28
       28
       +
             (* Create a waypoint *)

     

       29
       29
       +
             let waypoint = Waypoint.make lat lon 

     

       30
       30
       +
               |> Waypoint.with_name "San Francisco"

     

       31
       31
       +
               |> Waypoint.with_description "Golden Gate Bridge area" in

     

       32
       32
       +
             

     

       33
       33
       +
             (* Create GPX document *)

     

       34
       34
       +
             let gpx = make_gpx ~creator:"my-app" 

     

       35
       35
       +
               |> Doc.add_waypoint waypoint in

     

       36
       36
       +
             

     

       37
       37
       +
             (* Write to file or string *)

     

       38
       38
       +
             match write_string gpx with

     

       39
       39
       +
             | Ok xml -> print_endline xml

     

       40
       40
       +
             | Error e -> Printf.eprintf "Error: %s\n" (Error.to_string e)

     

       41
       41
       +
           ]}

     

       2
       42
        
           

     

       3
       43
        
           This library provides a clean, modular interface for working with GPX files,

     

       4
       4
       -
           the standard format for GPS data exchange. *)

     

       44
       44
       +
           with separate modules for each major component of the GPX specification. *)

     

       5
       45
        
       

     

       6
       46
        
       (** {1 Core Modules}

     

       7
       47
        
           

     

       8
       48
        
           The library is organized into focused modules, each handling a specific aspect

     

       9
       9
       -
           of GPX data. *)

     

       49
       49
       +
           of GPX data. Each module provides complete functionality for its domain with

     

       50
       50
       +
           strong type safety and validation. *)

     

       10
       51
        
       

     

       11
       11
       -
       (** Geographic coordinate handling with validation *)

     

       52
       52
       +
       (** {2 Geographic coordinate handling with validation}

     

       53
       53
       +
           

     

       54
       54
       +
           The {!Coordinate} module provides validated coordinate types for latitude,

     

       55
       55
       +
           longitude, and degrees. All coordinates use the WGS84 datum and are validated

     

       56
       56
       +
           at construction time to ensure they fall within valid ranges:

     

       57
       57
       +
           - Latitude: -90.0 to +90.0 degrees

     

       58
       58
       +
           - Longitude: -180.0 to +180.0 degrees  

     

       59
       59
       +
           - Degrees: 0.0 to 360.0 degrees

     

       60
       60
       +
           

     

       61
       61
       +
           Example: [Coordinate.latitude 37.7749] creates a validated latitude. *)

     

       12
       62
        
       module Coordinate = Coordinate

     

       13
       63
        
       

     

       14
       14
       -
       (** Links, persons, and copyright information *)

     

       64
       64
       +
       (** {2 Links, persons, and copyright information}

     

       65
       65
       +
           

     

       66
       66
       +
           The {!Link} module handles web links, author information, and copyright data

     

       67
       67
       +
           as defined in the GPX specification. This includes:

     

       68
       68
       +
           - Web links with optional text and MIME type

     

       69
       69
       +
           - Person records with name, email, and associated links

     

       70
       70
       +
           - Copyright information with author, year, and license terms *)

     

       15
       71
        
       module Link = Link

     

       16
       72
        
       

     

       17
       17
       -
       (** Extension mechanism for custom GPX elements *)

     

       73
       73
       +
       (** {2 Extension mechanism for custom GPX elements}

     

       74
       74
       +
           

     

       75
       75
       +
           The {!Extension} module provides support for custom XML elements that extend

     

       76
       76
       +
           the standard GPX format. Extensions allow applications to embed additional

     

       77
       77
       +
           data while maintaining compatibility with standard GPX readers. *)

     

       18
       78
        
       module Extension = Extension

     

       19
       79
        
       

     

       20
       20
       -
       (** GPS waypoint data and fix types *)

     

       80
       80
       +
       (** {2 GPS waypoint data and fix types}

     

       81
       81
       +
           

     

       82
       82
       +
           The {!Waypoint} module handles individual GPS points, including waypoints,

     

       83
       83
       +
           route points, and track points. Each waypoint contains:

     

       84
       84
       +
           - Required coordinates (latitude/longitude)

     

       85
       85
       +
           - Optional elevation in meters above mean sea level

     

       86
       86
       +
           - Optional timestamp

     

       87
       87
       +
           - Optional metadata like name, description, symbol

     

       88
       88
       +
           - Optional GPS quality information (accuracy, satellite count, etc.)

     

       89
       89
       +
           

     

       90
       90
       +
           Fix types indicate GPS quality: none, 2D, 3D, DGPS, or PPS. *)

     

       21
       91
        
       module Waypoint = Waypoint

     

       22
       92
        
       

     

       23
       23
       -
       (** GPX metadata including bounds *)

     

       93
       93
       +
       (** {2 GPX metadata including bounds}

     

       94
       94
       +
           

     

       95
       95
       +
           The {!Metadata} module handles document-level information:

     

       96
       96
       +
           - File name and description

     

       97
       97
       +
           - Author and copyright information

     

       98
       98
       +
           - Creation time and keywords

     

       99
       99
       +
           - Geographic bounding box of all data

     

       100
       100
       +
           - Links to related resources *)

     

       24
       101
        
       module Metadata = Metadata

     

       25
       102
        
       

     

       26
       26
       -
       (** Route data and calculations *)

     

       103
       103
       +
       (** {2 Route data and calculations}

     

       104
       104
       +
           

     

       105
       105
       +
           The {!Route} module handles planned paths represented as ordered sequences

     

       106
       106
       +
           of waypoints. Routes typically represent intended journeys rather than

     

       107
       107
       +
           recorded tracks. Each route can include:

     

       108
       108
       +
           - Ordered list of waypoints (route points)

     

       109
       109
       +
           - Route metadata (name, description, links)

     

       110
       110
       +
           - Distance calculations between points *)

     

       27
       111
        
       module Route = Route

     

       28
       112
        
       

     

       29
       29
       -
       (** Track data with segments *)

     

       113
       113
       +
       (** {2 Track data with segments}

     

       114
       114
       +
           

     

       115
       115
       +
           The {!Track} module handles recorded GPS traces, typically representing

     

       116
       116
       +
           actual journeys. Tracks are divided into segments to handle GPS interruptions:

     

       117
       117
       +
           - Track segments contain ordered track points

     

       118
       118
       +
           - Each track point is a timestamped waypoint

     

       119
       119
       +
           - Multiple segments per track handle GPS signal loss

     

       120
       120
       +
           - Distance and time calculations available *)

     

       30
       121
        
       module Track = Track

     

       31
       122
        
       

     

       32
       32
       -
       (** Error handling *)

     

       123
       123
       +
       (** {2 Error handling}

     

       124
       124
       +
           

     

       125
       125
       +
           The {!Error} module provides comprehensive error handling for GPX operations:

     

       126
       126
       +
           - XML parsing and validation errors

     

       127
       127
       +
           - Coordinate validation errors  

     

       128
       128
       +
           - Missing required elements or attributes

     

       129
       129
       +
           - File I/O errors *)

     

       33
       130
        
       module Error = Error

     

       34
       131
        
       

     

       35
       35
       -
       (** Main GPX document type *)

     

       36
       36
       -
       module Gpx_doc = Gpx_doc

     

       132
       132
       +
       (** {2 Main GPX document type}

     

       133
       133
       +
           

     

       134
       134
       +
           The {!Doc} module represents complete GPX documents containing:

     

       135
       135
       +
           - Document metadata (creator, version)

     

       136
       136
       +
           - Collections of waypoints, routes, and tracks

     

       137
       137
       +
           - Document-level extensions

     

       138
       138
       +
           - Statistics and analysis functions *)

     

       139
       139
       +
       module Doc = Doc

     

       37
       140
        
       

     

       38
       141
        
       (** {1 Main Document Type} *)

     

       39
       142
        
       

     

       40
       40
       -
       (** Main GPX document type *)

     

       41
       41
       -
       type t = Gpx_doc.t

     

       143
       143
       +
       (** A complete GPX document containing waypoints, routes, tracks, and metadata.

     

       144
       144
       +
           

     

       145
       145
       +
           This is the main type representing a complete GPX file. GPX documents must

     

       146
       146
       +
           have a creator string (identifying the creating application) and follow the

     

       147
       147
       +
           GPX 1.1 specification format. *)

     

       148
       148
       +
       type t = Doc.t

     

       42
       149
        
       

     

       43
       150
        
       (** {1 Error Handling} *)

     

       44
       151
        
       

     

       45
       45
       -
       (** Error types *)

     

       152
       152
       +
       (** Comprehensive error type covering all possible GPX operation failures.

     

       153
       153
       +
           

     

       154
       154
       +
           Errors can occur during:

     

       155
       155
       +
           - XML parsing (malformed XML, invalid structure)

     

       156
       156
       +
           - Coordinate validation (out of range values)

     

       157
       157
       +
           - Missing required GPX elements or attributes

     

       158
       158
       +
           - File I/O operations *)

     

       46
       159
        
       type error = Error.t

     

       47
       160
        
       

     

       48
       48
       -
       (** GPX exception raised for errors *)

     

       161
       161
       +
       (** GPX exception raised for unrecoverable errors.

     

       162
       162
       +
           

     

       163
       163
       +
           Most functions return [Result.t] for error handling, but this exception

     

       164
       164
       +
           may be raised in exceptional circumstances. *)

     

       49
       165
        
       exception Gpx_error of error

     

       50
       166
        
       

     

       51
       51
       -
       (** {1 Parsing Functions} *)

     

       167
       167
       +
       (** {1 Parsing Functions}

     

       168
       168
       +
           

     

       169
       169
       +
           Parse GPX data from various sources. All parsing functions support optional

     

       170
       170
       +
           validation to check compliance with GPX specification constraints. *)

     

       52
       171
        
       

     

       53
       53
       -
       (** Parse GPX from XML input.

     

       172
       172
       +
       (** Parse GPX from XML input source.

     

       54
       173
        
           

     

       55
       55
       -
           @param validate Whether to validate the document after parsing

     

       56
       56
       -
           @param input XMLm input source

     

       57
       57
       -
           @return Parsed GPX document or error *)

     

       174
       174
       +
           Reads GPX data from an {!Xmlm.input} source, which can be created from

     

       175
       175
       +
           files, strings, or other input sources using the {{:https://erratique.ch/software/xmlm}Xmlm} library.

     

       176
       176
       +
           

     

       177
       177
       +
           @param validate If [true] (default [false]), validates the parsed document

     

       178
       178
       +
                          against GPX specification rules. Validation checks coordinate

     

       179
       179
       +
                          ranges, required elements, and data consistency.

     

       180
       180
       +
           @param input XMLm input source created with [Xmlm.make_input]

     

       181
       181
       +
           @return [Ok gpx] with parsed document, or [Error e] if parsing fails

     

       182
       182
       +
           

     

       183
       183
       +
           Example:

     

       184
       184
       +
           {[

     

       185
       185
       +
             let input = Xmlm.make_input (`String (0, gpx_xml_string)) in

     

       186
       186
       +
             match parse ~validate:true input with

     

       187
       187
       +
             | Ok gpx -> Printf.printf "Parsed %d waypoints\n" (List.length (Doc.waypoints gpx))

     

       188
       188
       +
             | Error e -> Printf.eprintf "Parse error: %s\n" (Error.to_string e)

     

       189
       189
       +
           ]} *)

     

       58
       190
        
       val parse : ?validate:bool -> Xmlm.input -> (t, error) result

     

       59
       191
        
       

     

       60
       60
       -
       (** Parse GPX from string.

     

       192
       192
       +
       (** Parse GPX from XML string.

     

       193
       193
       +
           

     

       194
       194
       +
           Convenience function for parsing GPX data from a string. Equivalent to

     

       195
       195
       +
           creating an {!Xmlm.input} from the string and calling {!parse}.

     

       61
       196
        
           

     

       62
       62
       -
           @param validate Whether to validate the document after parsing  

     

       63
       63
       -
           @param s XML string to parse

     

       64
       64
       -
           @return Parsed GPX document or error *)

     

       197
       197
       +
           @param validate If [true] (default [false]), validates the parsed document

     

       198
       198
       +
           @param s Complete GPX XML document as a string

     

       199
       199
       +
           @return [Ok gpx] with parsed document, or [Error e] if parsing fails

     

       200
       200
       +
           

     

       201
       201
       +
           Example:

     

       202
       202
       +
           {[

     

       203
       203
       +
             let gpx_xml = {|<?xml version="1.0"?>

     

       204
       204
       +
             <gpx version="1.1" creator="my-app">

     

       205
       205
       +
               <wpt lat="37.7749" lon="-122.4194">

     

       206
       206
       +
                 <name>San Francisco</name>

     

       207
       207
       +
               </wpt>

     

       208
       208
       +
             </gpx>|} in

     

       209
       209
       +
             match parse_string ~validate:true gpx_xml with

     

       210
       210
       +
             | Ok gpx -> print_endline "Successfully parsed GPX"

     

       211
       211
       +
             | Error e -> Printf.eprintf "Error: %s\n" (Error.to_string e)

     

       212
       212
       +
           ]} *)

     

       65
       213
        
       val parse_string : ?validate:bool -> string -> (t, error) result

     

       66
       214
        
       

     

       67
       67
       -
       (** {1 Writing Functions} *)

     

       215
       215
       +
       (** {1 Writing Functions}

     

       216
       216
       +
           

     

       217
       217
       +
           Generate GPX XML from document structures. All writing functions support

     

       218
       218
       +
           optional validation before output generation. *)

     

       68
       219
        
       

     

       69
       69
       -
       (** Write GPX to XML output.

     

       220
       220
       +
       (** Write GPX to XML output destination.

     

       70
       221
        
           

     

       71
       71
       -
           @param validate Whether to validate before writing

     

       72
       72
       -
           @param output XMLm output destination

     

       222
       222
       +
           Generates standard GPX 1.1 XML and writes it to an {!Xmlm.dest} destination.

     

       223
       223
       +
           The output destination can target files, buffers, or other sinks.

     

       224
       224
       +
           

     

       225
       225
       +
           @param validate If [true] (default [false]), validates the document before

     

       226
       226
       +
                          writing to ensure GPX specification compliance

     

       227
       227
       +
           @param dest XMLm output destination created with [Xmlm.make_output]  

     

       73
       228
        
           @param gpx GPX document to write

     

       74
       74
       -
           @return Success or error *)

     

       229
       229
       +
           @return [Ok ()] on success, or [Error e] if writing fails

     

       230
       230
       +
           

     

       231
       231
       +
           Example:

     

       232
       232
       +
           {[

     

       233
       233
       +
             let output = Buffer.create 1024 in

     

       234
       234
       +
             let dest = Xmlm.make_output (`Buffer output) in

     

       235
       235
       +
             match write ~validate:true dest gpx with

     

       236
       236
       +
             | Ok () -> Buffer.contents output

     

       237
       237
       +
             | Error e -> failwith (Error.to_string e)

     

       238
       238
       +
           ]} *)

     

       75
       239
        
       val write : ?validate:bool -> Xmlm.dest -> t -> (unit, error) result

     

       76
       240
        
       

     

       77
       77
       -
       (** Write GPX to string.

     

       241
       241
       +
       (** Write GPX to XML string.

     

       242
       242
       +
           

     

       243
       243
       +
           Convenience function that generates a complete GPX XML document as a string.

     

       244
       244
       +
           The output includes XML declaration and proper namespace declarations.

     

       245
       245
       +
           

     

       246
       246
       +
           @param validate If [true] (default [false]), validates before writing

     

       247
       247
       +
           @param gpx GPX document to serialize

     

       248
       248
       +
           @return [Ok xml_string] with complete GPX XML, or [Error e] if generation fails

     

       78
       249
        
           

     

       79
       79
       -
           @param validate Whether to validate before writing

     

       80
       80
       -
           @param gpx GPX document to write  

     

       81
       81
       -
           @return XML string or error *)

     

       250
       250
       +
           Example:

     

       251
       251
       +
           {[

     

       252
       252
       +
             match write_string ~validate:true gpx with

     

       253
       253
       +
             | Ok xml -> 

     

       254
       254
       +
                 print_endline "Generated GPX:";

     

       255
       255
       +
                 print_endline xml

     

       256
       256
       +
             | Error e -> 

     

       257
       257
       +
                 Printf.eprintf "Failed to generate GPX: %s\n" (Error.to_string e)

     

       258
       258
       +
           ]} *)

     

       82
       259
        
       val write_string : ?validate:bool -> t -> (string, error) result

     

       83
       260
        
       

     

       84
       261
        
       (** {1 Validation Functions}

     

       85
       262
        
           

     

       86
       86
       -
           Validate GPX documents for correctness and best practices. *)

     

       263
       263
       +
           Comprehensive validation against GPX specification rules and best practices.

     

       264
       264
       +
           Validation checks coordinate ranges, required elements, data consistency,

     

       265
       265
       +
           and common issues that may cause problems for GPS applications. *)

     

       87
       266
        
       

     

       88
       88
       -
       (** Validation issue with severity level *)

     

       267
       267
       +
       (** A validation issue found during GPX document checking.

     

       268
       268
       +
           

     

       269
       269
       +
           Issues are classified as either errors (specification violations that make

     

       270
       270
       +
           the GPX invalid) or warnings (best practice violations or suspicious data). *)

     

       89
       271
        
       type validation_issue = Validate.validation_issue = {

     

       90
       90
       -
         level : [`Error | `Warning];     (** Severity level *)

     

       91
       91
       -
         message : string;                (** Issue description *)

     

       92
       92
       -
         location : string option;        (** Location in document *)

     

       272
       272
       +
         level : [`Error | `Warning];     (** [`Error] for specification violations, [`Warning] for best practice issues *)

     

       273
       273
       +
         message : string;                (** Human-readable description of the issue *)

     

       274
       274
       +
         location : string option;        (** Optional location context (e.g., "waypoint 1", "track segment 2") *)

     

       93
       275
        
       }

     

       94
       276
        
       

     

       95
       95
       -
       (** Result of validation containing all issues found *)

     

       277
       277
       +
       (** Complete validation result with all issues and validity status.

     

       278
       278
       +
           

     

       279
       279
       +
           The [is_valid] field indicates whether the document contains any errors.

     

       280
       280
       +
           Documents with only warnings are considered valid. *)

     

       96
       281
        
       type validation_result = Validate.validation_result = {

     

       97
       97
       -
         issues : validation_issue list;  (** All validation issues *)

     

       98
       98
       -
         is_valid : bool;                 (** Whether document is valid *)

     

       282
       282
       +
         issues : validation_issue list;  (** All validation issues found, both errors and warnings *)

     

       283
       283
       +
         is_valid : bool;                 (** [true] if no errors found (warnings are allowed) *)

     

       99
       284
        
       }

     

       100
       285
        
       

     

       101
       101
       -
       (** Validate complete GPX document *)

     

       286
       286
       +
       (** Perform comprehensive validation of a GPX document.

     

       287
       287
       +
           

     

       288
       288
       +
           Checks all aspects of the GPX document against the specification:

     

       289
       289
       +
           - Coordinate ranges (latitude -90 to +90, longitude -180 to +180)

     

       290
       290
       +
           - Required elements and attributes

     

       291
       291
       +
           - Data consistency (e.g., time ordering in tracks)

     

       292
       292
       +
           - Reasonable value ranges for GPS quality metrics

     

       293
       293
       +
           - Proper structure and nesting

     

       294
       294
       +
           

     

       295
       295
       +
           @param gpx The GPX document to validate

     

       296
       296
       +
           @return Complete validation result with all issues found

     

       297
       297
       +
           

     

       298
       298
       +
           Example:

     

       299
       299
       +
           {[

     

       300
       300
       +
             let result = validate_gpx gpx in

     

       301
       301
       +
             if result.is_valid then

     

       302
       302
       +
               Printf.printf "Document is valid with %d warnings\n" 

     

       303
       303
       +
                 (List.length (List.filter (fun i -> i.level = `Warning) result.issues))

     

       304
       304
       +
             else begin

     

       305
       305
       +
               print_endline "Document has errors:";

     

       306
       306
       +
               List.iter (fun issue ->

     

       307
       307
       +
                 if issue.level = `Error then

     

       308
       308
       +
                   Printf.printf "  ERROR: %s\n" (format_issue issue)

     

       309
       309
       +
               ) result.issues

     

       310
       310
       +
             end

     

       311
       311
       +
           ]} *)

     

       102
       312
        
       val validate_gpx : t -> validation_result

     

       103
       313
        
       

     

       104
       104
       -
       (** Quick validation - returns true if document is valid *)

     

       314
       314
       +
       (** Quick validation check - returns true if document has no errors.

     

       315
       315
       +
           

     

       316
       316
       +
           Equivalent to [(validate_gpx gpx).is_valid] but potentially more efficient

     

       317
       317
       +
           as it can stop at the first error found.

     

       318
       318
       +
           

     

       319
       319
       +
           @param gpx The GPX document to validate

     

       320
       320
       +
           @return [true] if valid (no errors), [false] if errors found *)

     

       105
       321
        
       val is_valid : t -> bool

     

       106
       322
        
       

     

       107
       107
       -
       (** Get only error messages *)

     

       108
       108
       -
       val get_errors : t -> validation_issue list

     

       323
       323
       +
       (** Get only validation errors (specification violations).

     

       324
       324
       +
           

     

       325
       325
       +
           Returns only the issues marked as errors, filtering out warnings.

     

       326
       326
       +
           If this list is empty, the document is valid according to the GPX specification.

     

       327
       327
       +
           

     

       328
       328
       +
           @param gpx The GPX document to validate

     

       329
       329
       +
           @return List of error-level validation issues *)

     

       330
       330
       +
       val errors : t -> validation_issue list

     

       109
       331
        
       

     

       110
       110
       -
       (** Get only warning messages *)

     

       111
       111
       -
       val get_warnings : t -> validation_issue list

     

       332
       332
       +
       (** Get only validation warnings (best practice violations).

     

       333
       333
       +
           

     

       334
       334
       +
           Returns only the issues marked as warnings. These don't make the document

     

       335
       335
       +
           invalid but may indicate potential problems or areas for improvement.

     

       336
       336
       +
           

     

       337
       337
       +
           @param gpx The GPX document to validate  

     

       338
       338
       +
           @return List of warning-level validation issues *)

     

       339
       339
       +
       val warnings : t -> validation_issue list

     

       112
       340
        
       

     

       113
       113
       -
       (** Format validation issue for display *)

     

       341
       341
       +
       (** Format a validation issue for human-readable display.

     

       342
       342
       +
           

     

       343
       343
       +
           Combines the issue message with location context if available.

     

       344
       344
       +
           

     

       345
       345
       +
           @param issue The validation issue to format

     

       346
       346
       +
           @return Formatted string suitable for display to users

     

       347
       347
       +
           

     

       348
       348
       +
           Example output: ["Error in waypoint 1: Latitude out of range (-95.0)"] *)

     

       114
       349
        
       val format_issue : validation_issue -> string

     

       115
       350
        
       

     

       116
       116
       -
       (** {1 Constructors and Utilities} *)

     

       351
       351
       +
       (** {1 Document Constructors and Utilities}

     

       352
       352
       +
           

     

       353
       353
       +
           Functions for creating GPX documents and basic document operations. *)

     

       117
       354
        
       

     

       118
       118
       -
       (** Create new GPX document with required fields *)

     

       355
       355
       +
       (** Create a new GPX document with the required creator field.

     

       356
       356
       +
           

     

       357
       357
       +
           Every GPX document must identify its creating application through the

     

       358
       358
       +
           [creator] attribute. This is required by the GPX specification and helps

     

       359
       359
       +
           identify the source of GPS data.

     

       360
       360
       +
           

     

       361
       361
       +
           The created document:

     

       362
       362
       +
           - Uses GPX version 1.1 (the current standard)

     

       363
       363
       +
           - Contains no waypoints, routes, or tracks initially

     

       364
       364
       +
           - Has no metadata initially

     

       365
       365
       +
           - Can be extended using {!Doc} module functions

     

       366
       366
       +
           

     

       367
       367
       +
           @param creator Name of the creating application (e.g., "MyGPS App v1.0")

     

       368
       368
       +
           @return Empty GPX document ready for data addition

     

       369
       369
       +
           

     

       370
       370
       +
           Example:

     

       371
       371
       +
           {[

     

       372
       372
       +
             let gpx = make_gpx ~creator:"MyTracker v2.1" in

     

       373
       373
       +
             let gpx = Doc.add_waypoint gpx some_waypoint in

     

       374
       374
       +
             let gpx = Doc.add_track gpx some_track in

     

       375
       375
       +
             (* gpx now contains waypoints and tracks *)

     

       376
       376
       +
           ]} *)

     

       119
       377
        
       val make_gpx : creator:string -> t

     

       120
       378
        
       

     

       121
       121
       -
       (** Create empty GPX document *)

     

       122
       122
       -
       val empty : creator:string -> t
     

       379
       379
       +
       (** Create an empty GPX document with the required creator field.

     

       380
       380
       +
           

     

       381
       381
       +
           Alias for {!make_gpx} provided for consistency with module naming patterns.

     

       382
       382
       +
           Creates a document with no GPS data that can be populated using the

     

       383
       383
       +
           {!Doc} module functions.

     

       384
       384
       +
           

     

       385
       385
       +
           @param creator Name of the creating application

     

       386
       386
       +
           @return Empty GPX document

     

       387
       387
       +
           

     

       388
       388
       +
           Example:

     

       389
       389
       +
           {[

     

       390
       390
       +
             let gpx = empty ~creator:"GPS Logger" in

     

       391
       391
       +
             assert (List.length (Doc.waypoints gpx) = 0);

     

       392
       392
       +
             assert (List.length (Doc.tracks gpx) = 0);

     

       393
       393
       +
             assert (Doc.creator gpx = "GPS Logger");

     

       394
       394
       +
           ]} *)

     

       395
       395
       +
       val empty : creator:string -> t

     

       396
       396
       +
       

     

       397
       397
       +
       (** {1 Common Patterns and Best Practices}

     

       398
       398
       +
           

     

       399
       399
       +
           {2 Reading GPX Files}

     

       400
       400
       +
           

     

       401
       401
       +
           The most common use case is reading existing GPX files:

     

       402
       402
       +
           {[

     

       403
       403
       +
             (* From a file using platform-specific modules *)

     

       404
       404
       +
             match Gpx_unix.read "track.gpx" with

     

       405
       405
       +
             | Ok gpx -> process_gpx gpx

     

       406
       406
       +
             | Error e -> handle_error e

     

       407
       407
       +
             

     

       408
       408
       +
             (* From a string *)

     

       409
       409
       +
             match parse_string ~validate:true gpx_content with

     

       410
       410
       +
             | Ok gpx -> process_gpx gpx

     

       411
       411
       +
             | Error e -> handle_error e

     

       412
       412
       +
           ]}

     

       413
       413
       +
           

     

       414
       414
       +
           {2 Creating GPX Files}

     

       415
       415
       +
           

     

       416
       416
       +
           To create new GPX files with waypoints:

     

       417
       417
       +
           {[

     

       418
       418
       +
             (* Create coordinates *)

     

       419
       419
       +
             let lat = Coordinate.latitude 37.7749 |> Result.get_ok in

     

       420
       420
       +
             let lon = Coordinate.longitude (-122.4194) |> Result.get_ok in

     

       421
       421
       +
             

     

       422
       422
       +
             (* Create waypoint *)

     

       423
       423
       +
             let waypoint = Waypoint.make lat lon

     

       424
       424
       +
               |> Waypoint.with_name "Golden Gate"

     

       425
       425
       +
               |> Waypoint.with_description "Famous San Francisco bridge" in

     

       426
       426
       +
             

     

       427
       427
       +
             (* Create document *)

     

       428
       428
       +
             let gpx = make_gpx ~creator:"My App v1.0"

     

       429
       429
       +
               |> Doc.add_waypoint waypoint in

     

       430
       430
       +
             

     

       431
       431
       +
             (* Write to file *)

     

       432
       432
       +
             match Gpx_unix.write "output.gpx" gpx with

     

       433
       433
       +
             | Ok () -> print_endline "File written successfully"

     

       434
       434
       +
             | Error e -> Printf.eprintf "Write error: %s\n" (Error.to_string e)

     

       435
       435
       +
           ]}

     

       436
       436
       +
           

     

       437
       437
       +
           {2 Working with Tracks}

     

       438
       438
       +
           

     

       439
       439
       +
           Tracks represent recorded GPS traces with timestamped points:

     

       440
       440
       +
           {[

     

       441
       441
       +
             (* Create track points with timestamps *)

     

       442
       442
       +
             let points = List.map (fun (lat_f, lon_f, time) ->

     

       443
       443
       +
               let lat = Coordinate.latitude lat_f |> Result.get_ok in

     

       444
       444
       +
               let lon = Coordinate.longitude lon_f |> Result.get_ok in

     

       445
       445
       +
               Waypoint.make lat lon |> Waypoint.with_time (Some time)

     

       446
       446
       +
             ) gps_data in

     

       447
       447
       +
             

     

       448
       448
       +
             (* Create track segment *)

     

       449
       449
       +
             let segment = Track.Segment.make points in

     

       450
       450
       +
             

     

       451
       451
       +
             (* Create track *)

     

       452
       452
       +
             let track = Track.make ~name:"Morning Run"

     

       453
       453
       +
               |> Track.add_segment segment in

     

       454
       454
       +
             

     

       455
       455
       +
             (* Add to document *)

     

       456
       456
       +
             let gpx = make_gpx ~creator:"Fitness App"

     

       457
       457
       +
               |> Doc.add_track track

     

       458
       458
       +
           ]}

     

       459
       459
       +
           

     

       460
       460
       +
           {2 Coordinate Systems and Units}

     

       461
       461
       +
           

     

       462
       462
       +
           - All coordinates use WGS84 datum (World Geodetic System 1984)

     

       463
       463
       +
           - Latitude ranges from -90.0 (South Pole) to +90.0 (North Pole)  

     

       464
       464
       +
           - Longitude ranges from -180.0 to +180.0 degrees

     

       465
       465
       +
           - Elevations are in meters above mean sea level

     

       466
       466
       +
           - Times use RFC 3339 format (ISO 8601 subset)

     

       467
       467
       +
           

     

       468
       468
       +
           {2 Validation Recommendations}

     

       469
       469
       +
           

     

       470
       470
       +
           - Always validate when parsing untrusted GPX data

     

       471
       471
       +
           - Validate before writing to catch data consistency issues

     

       472
       472
       +
           - Handle both errors and warnings appropriately

     

       473
       473
       +
           - Use {!val:is_valid} for quick checks, {!validate_gpx} for detailed analysis

     

       474
       474
       +
           

     

       475
       475
       +
           {2 Performance Considerations}

     

       476
       476
       +
           

     

       477
       477
       +
           - The library uses streaming XML parsing for memory efficiency

     

       478
       478
       +
           - Large GPX files with many track points are handled efficiently

     

       479
       479
       +
           - Coordinate validation occurs at construction time

     

       480
       480
       +
           - Consider using platform-specific modules ({!Gpx_unix}, [Gpx_eio]) for file I/O

     

       481
       481
       +
           

     

       482
       482
       +
           {2 Extension Support}

     

       483
       483
       +
           

     

       484
       484
       +
           The library supports GPX extensions for custom data:

     

       485
       485
       +
           {[

     

       486
       486
       +
             (* Create extension *)

     

       487
       487
       +
             let ext = Extension.make_text

     

       488
       488
       +
               ~name:"temperature" 

     

       489
       489
       +
               ~namespace:"http://example.com/weather"

     

       490
       490
       +
               "25.5" in

     

       491
       491
       +
             

     

       492
       492
       +
             (* Add to waypoint *)

     

       493
       493
       +
             let waypoint = Waypoint.make lat lon

     

       494
       494
       +
               |> Waypoint.add_extensions [ext]

     

       495
       495
       +
           ]} *)

     

       496
       496
       +
       

     

       497
       497
       +
       (** {1 Related Modules and Libraries}

     

       498
       498
       +
           

     

       499
       499
       +
           This core module provides the foundation. For complete applications, consider:

     

       500
       500
       +
           

     

       501
       501
       +
           - {!Gpx_unix}: File I/O operations using standard Unix libraries

     

       502
       502
       +
           - {!Gpx_eio}: Concurrent file I/O using the Eio effects library  

     

       503
       503
       +
           - {{:https://erratique.ch/software/xmlm}Xmlm}: Underlying XML processing library

     

       504
       504
       +
           - {{:https://erratique.ch/software/ptime}Ptime}: Time representation used for timestamps

     

       505
       505
       +
           

     

       506
       506
       +
           {2 External Links}

     

       507
       507
       +
           

     

       508
       508
       +
           - {{:https://www.topografix.com/gpx.asp}Official GPX specification}

     

       509
       509
       +
           - {{:https://www.topografix.com/GPX/1/1/gpx.xsd}GPX 1.1 XML Schema}

     

       510
       510
       +
           - {{:https://en.wikipedia.org/wiki/GPS_Exchange_Format}GPX Format on Wikipedia}

     

       511
       511
       +
           - {{:https://en.wikipedia.org/wiki/World_Geodetic_System}WGS84 Coordinate System} *)

-196

lib/gpx/gpx_doc.ml

···

       1
       1
       -
       (** Main GPX document type *)

     

       2
       2
       -
       

     

       3
       3
       -
       (** Main GPX document type *)

     

       4
       4
       -
       type t = {

     

       5
       5
       -
         version : string;                    (* GPX version: "1.0" or "1.1" *)

     

       6
       6
       -
         creator : string;                    (* Creating application *)

     

       7
       7
       -
         metadata : Metadata.t option;       (* Document metadata *)

     

       8
       8
       -
         waypoints : Waypoint.t list;        (* Waypoints *)

     

       9
       9
       -
         routes : Route.t list;               (* Routes *)

     

       10
       10
       -
         tracks : Track.t list;               (* Tracks *)

     

       11
       11
       -
         extensions : Extension.t list;       (* Document-level extensions *)

     

       12
       12
       -
       }

     

       13
       13
       -
       

     

       14
       14
       -
       (** {2 Document Constructors} *)

     

       15
       15
       -
       

     

       16
       16
       -
       (** Create empty GPX document *)

     

       17
       17
       -
       let empty ~creator = {

     

       18
       18
       -
         version = "1.1";

     

       19
       19
       -
         creator;

     

       20
       20
       -
         metadata = None;

     

       21
       21
       -
         waypoints = [];

     

       22
       22
       -
         routes = [];

     

       23
       23
       -
         tracks = [];

     

       24
       24
       -
         extensions = [];

     

       25
       25
       -
       }

     

       26
       26
       -
       

     

       27
       27
       -
       (** Create GPX document with metadata *)

     

       28
       28
       -
       let make ~creator ~metadata = 

     

       29
       29
       -
         { (empty ~creator) with metadata = Some metadata }

     

       30
       30
       -
       

     

       31
       31
       -
       (** {2 Document Properties} *)

     

       32
       32
       -
       

     

       33
       33
       -
       (** Get version *)

     

       34
       34
       -
       let get_version t = t.version

     

       35
       35
       -
       

     

       36
       36
       -
       (** Get creator *)

     

       37
       37
       -
       let get_creator t = t.creator

     

       38
       38
       -
       

     

       39
       39
       -
       (** Get metadata *)

     

       40
       40
       -
       let get_metadata t = t.metadata

     

       41
       41
       -
       

     

       42
       42
       -
       (** Get waypoints *)

     

       43
       43
       -
       let get_waypoints t = t.waypoints

     

       44
       44
       -
       

     

       45
       45
       -
       (** Get routes *)

     

       46
       46
       -
       let get_routes t = t.routes

     

       47
       47
       -
       

     

       48
       48
       -
       (** Get tracks *)

     

       49
       49
       -
       let get_tracks t = t.tracks

     

       50
       50
       -
       

     

       51
       51
       -
       (** Get extensions *)

     

       52
       52
       -
       let get_extensions t = t.extensions

     

       53
       53
       -
       

     

       54
       54
       -
       (** {2 Document Modification} *)

     

       55
       55
       -
       

     

       56
       56
       -
       (** Set version *)

     

       57
       57
       -
       let with_version t version = { t with version }

     

       58
       58
       -
       

     

       59
       59
       -
       (** Set metadata *)

     

       60
       60
       -
       let with_metadata t metadata = { t with metadata = Some metadata }

     

       61
       61
       -
       

     

       62
       62
       -
       (** Set metadata *)

     

       63
       63
       -
       let set_metadata metadata t = { t with metadata = Some metadata }

     

       64
       64
       -
       

     

       65
       65
       -
       (** Add waypoint *)

     

       66
       66
       -
       let add_waypoint t waypoint = { t with waypoints = t.waypoints @ [waypoint] }

     

       67
       67
       -
       

     

       68
       68
       -
       (** Add waypoints *)

     

       69
       69
       -
       let add_waypoints t waypoints = { t with waypoints = t.waypoints @ waypoints }

     

       70
       70
       -
       

     

       71
       71
       -
       (** Add route *)

     

       72
       72
       -
       let add_route t route = { t with routes = t.routes @ [route] }

     

       73
       73
       -
       

     

       74
       74
       -
       (** Add routes *)

     

       75
       75
       -
       let add_routes t routes = { t with routes = t.routes @ routes }

     

       76
       76
       -
       

     

       77
       77
       -
       (** Add track *)

     

       78
       78
       -
       let add_track t track = { t with tracks = t.tracks @ [track] }

     

       79
       79
       -
       

     

       80
       80
       -
       (** Add tracks *)

     

       81
       81
       -
       let add_tracks t tracks = { t with tracks = t.tracks @ tracks }

     

       82
       82
       -
       

     

       83
       83
       -
       (** Add extensions *)

     

       84
       84
       -
       let add_extensions t extensions = { t with extensions = t.extensions @ extensions }

     

       85
       85
       -
       

     

       86
       86
       -
       (** Clear waypoints *)

     

       87
       87
       -
       let clear_waypoints t = { t with waypoints = [] }

     

       88
       88
       -
       

     

       89
       89
       -
       (** Clear routes *)

     

       90
       90
       -
       let clear_routes t = { t with routes = [] }

     

       91
       91
       -
       

     

       92
       92
       -
       (** Clear tracks *)

     

       93
       93
       -
       let clear_tracks t = { t with tracks = [] }

     

       94
       94
       -
       

     

       95
       95
       -
       (** {2 Document Analysis} *)

     

       96
       96
       -
       

     

       97
       97
       -
       (** Count waypoints *)

     

       98
       98
       -
       let waypoint_count t = List.length t.waypoints

     

       99
       99
       -
       

     

       100
       100
       -
       (** Count routes *)

     

       101
       101
       -
       let route_count t = List.length t.routes

     

       102
       102
       -
       

     

       103
       103
       -
       (** Count tracks *)

     

       104
       104
       -
       let track_count t = List.length t.tracks

     

       105
       105
       -
       

     

       106
       106
       -
       (** Count total points *)

     

       107
       107
       -
       let total_points t =

     

       108
       108
       -
         let waypoint_points = List.length t.waypoints in

     

       109
       109
       -
         let route_points = List.fold_left (fun acc route -> 

     

       110
       110
       -
           acc + Route.point_count route) 0 t.routes in

     

       111
       111
       -
         let track_points = List.fold_left (fun acc track -> 

     

       112
       112
       -
           acc + Track.point_count track) 0 t.tracks in

     

       113
       113
       -
         waypoint_points + route_points + track_points

     

       114
       114
       -
       

     

       115
       115
       -
       (** Check if document has elevation data *)

     

       116
       116
       -
       let has_elevation t =

     

       117
       117
       -
         List.exists (fun wpt -> Waypoint.get_elevation wpt <> None) t.waypoints ||

     

       118
       118
       -
         List.exists (fun route ->

     

       119
       119
       -
           List.exists (fun pt -> Waypoint.get_elevation pt <> None) (Route.get_points route)

     

       120
       120
       -
         ) t.routes ||

     

       121
       121
       -
         List.exists (fun track ->

     

       122
       122
       -
           List.exists (fun pt -> Waypoint.get_elevation pt <> None) (Track.all_points track)

     

       123
       123
       -
         ) t.tracks

     

       124
       124
       -
       

     

       125
       125
       -
       (** Check if document has time data *)

     

       126
       126
       -
       let has_time t =

     

       127
       127
       -
         List.exists (fun wpt -> Waypoint.get_time wpt <> None) t.waypoints ||

     

       128
       128
       -
         List.exists (fun route ->

     

       129
       129
       -
           List.exists (fun pt -> Waypoint.get_time pt <> None) (Route.get_points route)

     

       130
       130
       -
         ) t.routes ||

     

       131
       131
       -
         List.exists (fun track ->

     

       132
       132
       -
           List.exists (fun pt -> Waypoint.get_time pt <> None) (Track.all_points track)

     

       133
       133
       -
         ) t.tracks

     

       134
       134
       -
       

     

       135
       135
       -
       (** Check if document is empty *)

     

       136
       136
       -
       let is_empty t = 

     

       137
       137
       -
         waypoint_count t = 0 && route_count t = 0 && track_count t = 0

     

       138
       138
       -
       

     

       139
       139
       -
       (** Get statistics *)

     

       140
       140
       -
       type stats = {

     

       141
       141
       -
         waypoint_count : int;

     

       142
       142
       -
         route_count : int;

     

       143
       143
       -
         track_count : int;

     

       144
       144
       -
         total_points : int;

     

       145
       145
       -
         has_elevation : bool;

     

       146
       146
       -
         has_time : bool;

     

       147
       147
       -
       }

     

       148
       148
       -
       

     

       149
       149
       -
       let get_stats t = {

     

       150
       150
       -
         waypoint_count = waypoint_count t;

     

       151
       151
       -
         route_count = route_count t;

     

       152
       152
       -
         track_count = track_count t;

     

       153
       153
       -
         total_points = total_points t;

     

       154
       154
       -
         has_elevation = has_elevation t;

     

       155
       155
       -
         has_time = has_time t;

     

       156
       156
       -
       }

     

       157
       157
       -
       

     

       158
       158
       -
       (** {2 Comparison and Utilities} *)

     

       159
       159
       -
       

     

       160
       160
       -
       (** Compare documents *)

     

       161
       161
       -
       let compare t1 t2 =

     

       162
       162
       -
         let version_cmp = String.compare t1.version t2.version in

     

       163
       163
       -
         if version_cmp <> 0 then version_cmp

     

       164
       164
       -
         else

     

       165
       165
       -
           let creator_cmp = String.compare t1.creator t2.creator in

     

       166
       166
       -
           if creator_cmp <> 0 then creator_cmp

     

       167
       167
       -
           else

     

       168
       168
       -
             let waypoints_cmp = List.compare Waypoint.compare t1.waypoints t2.waypoints in

     

       169
       169
       -
             if waypoints_cmp <> 0 then waypoints_cmp

     

       170
       170
       -
             else

     

       171
       171
       -
               let routes_cmp = List.compare Route.compare t1.routes t2.routes in

     

       172
       172
       -
               if routes_cmp <> 0 then routes_cmp

     

       173
       173
       -
               else List.compare Track.compare t1.tracks t2.tracks

     

       174
       174
       -
       

     

       175
       175
       -
       (** Test document equality *)

     

       176
       176
       -
       let equal t1 t2 = compare t1 t2 = 0

     

       177
       177
       -
       

     

       178
       178
       -
       (** Pretty print document *)

     

       179
       179
       -
       let pp ppf t =

     

       180
       180
       -
         let stats = get_stats t in

     

       181
       181
       -
         Format.fprintf ppf "GPX v%s by %s (%d wpt, %d routes, %d tracks, %d total points)"

     

       182
       182
       -
           t.version t.creator 

     

       183
       183
       -
           stats.waypoint_count stats.route_count stats.track_count stats.total_points

     

       184
       184
       -
       

     

       185
       185
       -
       (** Print document statistics *)

     

       186
       186
       -
       let print_stats t =

     

       187
       187
       -
         let stats = get_stats t in

     

       188
       188
       -
         Printf.printf "GPX Statistics:\n";

     

       189
       189
       -
         Printf.printf "  Version: %s\n" t.version;

     

       190
       190
       -
         Printf.printf "  Creator: %s\n" t.creator;

     

       191
       191
       -
         Printf.printf "  Waypoints: %d\n" stats.waypoint_count;

     

       192
       192
       -
         Printf.printf "  Routes: %d\n" stats.route_count;

     

       193
       193
       -
         Printf.printf "  Tracks: %d\n" stats.track_count;

     

       194
       194
       -
         Printf.printf "  Total points: %d\n" stats.total_points;

     

       195
       195
       -
         Printf.printf "  Has elevation data: %s\n" (if stats.has_elevation then "yes" else "no");

     

       196
       196
       -
         Printf.printf "  Has time data: %s\n" (if stats.has_time then "yes" else "no")

-134

lib/gpx/gpx_doc.mli

···

       1
       1
       -
       (** Main GPX document type *)

     

       2
       2
       -
       

     

       3
       3
       -
       (** Main GPX document type *)

     

       4
       4
       -
       type t = {

     

       5
       5
       -
         version : string;                    (* GPX version: "1.0" or "1.1" *)

     

       6
       6
       -
         creator : string;                    (* Creating application *)

     

       7
       7
       -
         metadata : Metadata.t option;       (* Document metadata *)

     

       8
       8
       -
         waypoints : Waypoint.t list;        (* Waypoints *)

     

       9
       9
       -
         routes : Route.t list;               (* Routes *)

     

       10
       10
       -
         tracks : Track.t list;               (* Tracks *)

     

       11
       11
       -
         extensions : Extension.t list;       (* Document-level extensions *)

     

       12
       12
       -
       }

     

       13
       13
       -
       

     

       14
       14
       -
       (** Document statistics *)

     

       15
       15
       -
       type stats = {

     

       16
       16
       -
         waypoint_count : int;

     

       17
       17
       -
         route_count : int;

     

       18
       18
       -
         track_count : int;

     

       19
       19
       -
         total_points : int;

     

       20
       20
       -
         has_elevation : bool;

     

       21
       21
       -
         has_time : bool;

     

       22
       22
       -
       }

     

       23
       23
       -
       

     

       24
       24
       -
       (** {2 Document Constructors} *)

     

       25
       25
       -
       

     

       26
       26
       -
       (** Create empty GPX document *)

     

       27
       27
       -
       val empty : creator:string -> t

     

       28
       28
       -
       

     

       29
       29
       -
       (** Create GPX document with metadata *)

     

       30
       30
       -
       val make : creator:string -> metadata:Metadata.t -> t

     

       31
       31
       -
       

     

       32
       32
       -
       (** {2 Document Properties} *)

     

       33
       33
       -
       

     

       34
       34
       -
       (** Get version *)

     

       35
       35
       -
       val get_version : t -> string

     

       36
       36
       -
       

     

       37
       37
       -
       (** Get creator *)

     

       38
       38
       -
       val get_creator : t -> string

     

       39
       39
       -
       

     

       40
       40
       -
       (** Get metadata *)

     

       41
       41
       -
       val get_metadata : t -> Metadata.t option

     

       42
       42
       -
       

     

       43
       43
       -
       (** Get waypoints *)

     

       44
       44
       -
       val get_waypoints : t -> Waypoint.t list

     

       45
       45
       -
       

     

       46
       46
       -
       (** Get routes *)

     

       47
       47
       -
       val get_routes : t -> Route.t list

     

       48
       48
       -
       

     

       49
       49
       -
       (** Get tracks *)

     

       50
       50
       -
       val get_tracks : t -> Track.t list

     

       51
       51
       -
       

     

       52
       52
       -
       (** Get extensions *)

     

       53
       53
       -
       val get_extensions : t -> Extension.t list

     

       54
       54
       -
       

     

       55
       55
       -
       (** {2 Document Modification} *)

     

       56
       56
       -
       

     

       57
       57
       -
       (** Set version *)

     

       58
       58
       -
       val with_version : t -> string -> t

     

       59
       59
       -
       

     

       60
       60
       -
       (** Set metadata *)

     

       61
       61
       -
       val with_metadata : t -> Metadata.t -> t

     

       62
       62
       -
       

     

       63
       63
       -
       (** Set metadata *)

     

       64
       64
       -
       val set_metadata : Metadata.t -> t -> t

     

       65
       65
       -
       

     

       66
       66
       -
       (** Add waypoint *)

     

       67
       67
       -
       val add_waypoint : t -> Waypoint.t -> t

     

       68
       68
       -
       

     

       69
       69
       -
       (** Add waypoints *)

     

       70
       70
       -
       val add_waypoints : t -> Waypoint.t list -> t

     

       71
       71
       -
       

     

       72
       72
       -
       (** Add route *)

     

       73
       73
       -
       val add_route : t -> Route.t -> t

     

       74
       74
       -
       

     

       75
       75
       -
       (** Add routes *)

     

       76
       76
       -
       val add_routes : t -> Route.t list -> t

     

       77
       77
       -
       

     

       78
       78
       -
       (** Add track *)

     

       79
       79
       -
       val add_track : t -> Track.t -> t

     

       80
       80
       -
       

     

       81
       81
       -
       (** Add tracks *)

     

       82
       82
       -
       val add_tracks : t -> Track.t list -> t

     

       83
       83
       -
       

     

       84
       84
       -
       (** Add extensions *)

     

       85
       85
       -
       val add_extensions : t -> Extension.t list -> t

     

       86
       86
       -
       

     

       87
       87
       -
       (** Clear waypoints *)

     

       88
       88
       -
       val clear_waypoints : t -> t

     

       89
       89
       -
       

     

       90
       90
       -
       (** Clear routes *)

     

       91
       91
       -
       val clear_routes : t -> t

     

       92
       92
       -
       

     

       93
       93
       -
       (** Clear tracks *)

     

       94
       94
       -
       val clear_tracks : t -> t

     

       95
       95
       -
       

     

       96
       96
       -
       (** {2 Document Analysis} *)

     

       97
       97
       -
       

     

       98
       98
       -
       (** Count waypoints *)

     

       99
       99
       -
       val waypoint_count : t -> int

     

       100
       100
       -
       

     

       101
       101
       -
       (** Count routes *)

     

       102
       102
       -
       val route_count : t -> int

     

       103
       103
       -
       

     

       104
       104
       -
       (** Count tracks *)

     

       105
       105
       -
       val track_count : t -> int

     

       106
       106
       -
       

     

       107
       107
       -
       (** Count total points *)

     

       108
       108
       -
       val total_points : t -> int

     

       109
       109
       -
       

     

       110
       110
       -
       (** Check if document has elevation data *)

     

       111
       111
       -
       val has_elevation : t -> bool

     

       112
       112
       -
       

     

       113
       113
       -
       (** Check if document has time data *)

     

       114
       114
       -
       val has_time : t -> bool

     

       115
       115
       -
       

     

       116
       116
       -
       (** Check if document is empty *)

     

       117
       117
       -
       val is_empty : t -> bool

     

       118
       118
       -
       

     

       119
       119
       -
       (** Get document statistics *)

     

       120
       120
       -
       val get_stats : t -> stats

     

       121
       121
       -
       

     

       122
       122
       -
       (** {2 Comparison and Utilities} *)

     

       123
       123
       -
       

     

       124
       124
       -
       (** Compare documents *)

     

       125
       125
       -
       val compare : t -> t -> int

     

       126
       126
       -
       

     

       127
       127
       -
       (** Test document equality *)

     

       128
       128
       -
       val equal : t -> t -> bool

     

       129
       129
       -
       

     

       130
       130
       -
       (** Pretty print document *)

     

       131
       131
       -
       val pp : Format.formatter -> t -> unit

     

       132
       132
       -
       

     

       133
       133
       -
       (** Print document statistics to stdout *)

     

       134
       134
       -
       val print_stats : t -> unit

+11 -11

lib/gpx/link.ml

···

       27
       27
        
       let make ~href ?text ?type_ () = { href; text; type_ }

     

       28
       28
        
       

     

       29
       29
        
       (** Get href from link *)

     

       30
       30
       -
       let get_href t = t.href

     

       30
       30
       +
       let href t = t.href

     

       31
       31
        
       

     

       32
       32
        
       (** Get optional text from link *)

     

       33
       33
       -
       let get_text t = t.text

     

       33
       33
       +
       let text t = t.text

     

       34
       34
        
       

     

       35
       35
        
       (** Get optional type from link *)

     

       36
       36
       -
       let get_type t = t.type_

     

       36
       36
       +
       let type_ t = t.type_

     

       37
       37
        
       

     

       38
       38
       -
       (** Set text on link *)

     

       38
       38
       +
       (** Update text *)

     

       39
       39
        
       let with_text t text = { t with text = Some text }

     

       40
       40
        
       

     

       41
       41
       -
       (** Set type on link *)

     

       41
       41
       +
       (** Update type *)

     

       42
       42
        
       let with_type t type_ = { t with type_ = Some type_ }

     

       43
       43
        
       

     

       44
       44
        
       (** Compare links *)

     
···

       65
       65
        
       let make_person ?name ?email ?link () = { name; email; link }

     

       66
       66
        
       

     

       67
       67
        
       (** Get person name *)

     

       68
       68
       -
       let get_person_name (p : person) = p.name

     

       68
       68
       +
       let person_name (p : person) = p.name

     

       69
       69
        
       

     

       70
       70
        
       (** Get person email *)

     

       71
       71
       -
       let get_person_email (p : person) = p.email

     

       71
       71
       +
       let person_email (p : person) = p.email

     

       72
       72
        
       

     

       73
       73
        
       (** Get person link *)

     

       74
       74
       -
       let get_person_link (p : person) = p.link

     

       74
       74
       +
       let person_link (p : person) = p.link

     

       75
       75
        
       

     

       76
       76
        
       (** Compare persons *)

     

       77
       77
        
       let compare_person p1 p2 =

     
···

       99
       99
        
       let make_copyright ~author ?year ?license () = { author; year; license }

     

       100
       100
        
       

     

       101
       101
        
       (** Get copyright author *)

     

       102
       102
       -
       let get_copyright_author (c : copyright) = c.author

     

       102
       102
       +
       let copyright_author (c : copyright) = c.author

     

       103
       103
        
       

     

       104
       104
        
       (** Get copyright year *)

     

       105
       105
       -
       let get_copyright_year (c : copyright) = c.year

     

       105
       105
       +
       let copyright_year (c : copyright) = c.year

     

       106
       106
        
       

     

       107
       107
        
       (** Get copyright license *)

     

       108
       108
       -
       let get_copyright_license (c : copyright) = c.license

     

       108
       108
       +
       let copyright_license (c : copyright) = c.license

     

       109
       109
        
       

     

       110
       110
        
       (** Compare copyrights *)

     

       111
       111
        
       let compare_copyright c1 c2 =

+12 -11

lib/gpx/link.mli

···

       30
       30
        
       val make : href:string -> ?text:string -> ?type_:string -> unit -> t

     

       31
       31
        
       

     

       32
       32
        
       (** Get href from link *)

     

       33
       33
       -
       val get_href : t -> string

     

       33
       33
       +
       val href : t -> string

     

       34
       34
        
       

     

       35
       35
        
       (** Get optional text from link *)

     

       36
       36
       -
       val get_text : t -> string option

     

       36
       36
       +
       val text : t -> string option

     

       37
       37
        
       

     

       38
       38
        
       (** Get optional type from link *)

     

       39
       39
       -
       val get_type : t -> string option

     

       39
       39
       +
       val type_ : t -> string option

     

       40
       40
        
       

     

       41
       41
       -
       (** Set text on link *)

     

       41
       41
       +
       (** Update text *)

     

       42
       42
        
       val with_text : t -> string -> t

     

       43
       43
        
       

     

       44
       44
       -
       (** Set type on link *)

     

       44
       44
       +
       (** Update type *)

     

       45
       45
        
       val with_type : t -> string -> t

     

       46
       46
       +
       

     

       46
       47
        
       

     

       47
       48
        
       (** Compare links *)

     

       48
       49
        
       val compare : t -> t -> int

     
···

       59
       60
        
       val make_person : ?name:string -> ?email:string -> ?link:t -> unit -> person

     

       60
       61
        
       

     

       61
       62
        
       (** Get person name *)

     

       62
       62
       -
       val get_person_name : person -> string option

     

       63
       63
       +
       val person_name : person -> string option

     

       63
       64
        
       

     

       64
       65
        
       (** Get person email *)

     

       65
       65
       -
       val get_person_email : person -> string option

     

       66
       66
       +
       val person_email : person -> string option

     

       66
       67
        
       

     

       67
       68
        
       (** Get person link *)

     

       68
       68
       -
       val get_person_link : person -> t option

     

       69
       69
       +
       val person_link : person -> t option

     

       69
       70
        
       

     

       70
       71
        
       (** Compare persons *)

     

       71
       72
        
       val compare_person : person -> person -> int

     
···

       82
       83
        
       val make_copyright : author:string -> ?year:int -> ?license:string -> unit -> copyright

     

       83
       84
        
       

     

       84
       85
        
       (** Get copyright author *)

     

       85
       85
       -
       val get_copyright_author : copyright -> string

     

       86
       86
       +
       val copyright_author : copyright -> string

     

       86
       87
        
       

     

       87
       88
        
       (** Get copyright year *)

     

       88
       88
       -
       val get_copyright_year : copyright -> int option

     

       89
       89
       +
       val copyright_year : copyright -> int option

     

       89
       90
        
       

     

       90
       91
        
       (** Get copyright license *)

     

       91
       91
       -
       val get_copyright_license : copyright -> string option

     

       92
       92
       +
       val copyright_license : copyright -> string option

     

       92
       93
        
       

     

       93
       94
        
       (** Compare copyrights *)

     

       94
       95
        
       val compare_copyright : copyright -> copyright -> int

+31 -30

lib/gpx/metadata.ml

···

       45
       45
        
           | Error e, _, _, _ | _, Error e, _, _ | _, _, Error e, _ | _, _, _, Error e -> Error e

     

       46
       46
        
       

     

       47
       47
        
         (** Get corner coordinates *)

     

       48
       48
       -
         let get_min_coords t = Coordinate.make t.minlat t.minlon

     

       49
       49
       -
         let get_max_coords t = Coordinate.make t.maxlat t.maxlon

     

       48
       48
       +
         let min_coords t = Coordinate.make t.minlat t.minlon

     

       49
       49
       +
         let max_coords t = Coordinate.make t.maxlat t.maxlon

     

       50
       50
        
       

     

       51
       51
        
         (** Get all bounds as tuple *)

     

       52
       52
       -
         let get_bounds t = (t.minlat, t.minlon, t.maxlat, t.maxlon)

     

       52
       52
       +
         let bounds t = (t.minlat, t.minlon, t.maxlat, t.maxlon)

     

       53
       53
        
       

     

       54
       54
        
         (** Check if coordinate is within bounds *)

     

       55
       55
        
         let contains bounds coord =

     

       56
       56
       -
           let lat = Coordinate.get_lat coord in

     

       57
       57
       -
           let lon = Coordinate.get_lon coord in

     

       56
       56
       +
           let lat = Coordinate.lat coord in

     

       57
       57
       +
           let lon = Coordinate.lon coord in

     

       58
       58
        
           Coordinate.latitude_to_float bounds.minlat <= Coordinate.latitude_to_float lat &&

     

       59
       59
        
           Coordinate.latitude_to_float lat <= Coordinate.latitude_to_float bounds.maxlat &&

     

       60
       60
        
           Coordinate.longitude_to_float bounds.minlon <= Coordinate.longitude_to_float lon &&

     
···

       111
       111
        
       let make ~name = { empty with name = Some name }

     

       112
       112
        
       

     

       113
       113
        
       (** Get name *)

     

       114
       114
       -
       let get_name t = t.name

     

       114
       114
       +
       let name t = t.name

     

       115
       115
        
       

     

       116
       116
        
       (** Get description *)  

     

       117
       117
       -
       let get_description t = t.desc

     

       117
       117
       +
       let description t = t.desc

     

       118
       118
        
       

     

       119
       119
        
       (** Get author *)

     

       120
       120
       -
       let get_author t = t.author

     

       120
       120
       +
       let author t = t.author

     

       121
       121
        
       

     

       122
       122
        
       (** Get copyright *)

     

       123
       123
       -
       let get_copyright t = t.copyright

     

       123
       123
       +
       let copyright t = t.copyright

     

       124
       124
        
       

     

       125
       125
        
       (** Get links *)

     

       126
       126
       -
       let get_links t = t.links

     

       126
       126
       +
       let links t = t.links

     

       127
       127
        
       

     

       128
       128
        
       (** Get time *)

     

       129
       129
       -
       let get_time t = t.time

     

       129
       129
       +
       let time t = t.time

     

       130
       130
        
       

     

       131
       131
        
       (** Get keywords *)

     

       132
       132
       -
       let get_keywords t = t.keywords

     

       132
       132
       +
       let keywords t = t.keywords

     

       133
       133
        
       

     

       134
       134
        
       (** Get bounds *)

     

       135
       135
       -
       let get_bounds t = t.bounds

     

       135
       135
       +
       let bounds_opt t = t.bounds

     

       136
       136
        
       

     

       137
       137
       -
       (** Set name *)

     

       138
       138
       -
       let set_name name t = { t with name = Some name }

     

       137
       137
       +
       (** Get extensions *)

     

       138
       138
       +
       let extensions t = t.extensions

     

       139
       139
        
       

     

       140
       140
       -
       (** Set description *)

     

       141
       141
       -
       let set_description desc t = { t with desc = Some desc }

     

       142
       142
       -
       

     

       143
       143
       -
       (** Set author *)

     

       144
       144
       -
       let set_author author t = { t with author = Some author }

     

       145
       145
       -
       

     

       146
       146
       -
       (** Add link *)

     

       147
       147
       -
       let add_link t link = { t with links = link :: t.links }

     

       148
       148
       -
       

     

       149
       149
       -
       (** Functional setters for building metadata *)

     

       150
       150
       -
       

     

       151
       151
       -
       (** Set name *)

     

       140
       140
       +
       (** Update name *)

     

       152
       141
        
       let with_name t name = { t with name = Some name }

     

       153
       142
        
       

     

       154
       154
       -
       (** Set description *)

     

       143
       143
       +
       (** Update description *)

     

       155
       144
        
       let with_description t desc = { t with desc = Some desc }

     

       156
       145
        
       

     

       157
       157
       -
       (** Set keywords *)

     

       146
       146
       +
       (** Update keywords *)

     

       158
       147
        
       let with_keywords t keywords = { t with keywords = Some keywords }

     

       159
       148
        
       

     

       160
       160
       -
       (** Set time *)

     

       149
       149
       +
       (** Update time *)

     

       161
       150
        
       let with_time t time = { t with time }

     

       151
       151
       +
       

     

       152
       152
       +
       (** Update bounds *)

     

       153
       153
       +
       let with_bounds t bounds = { t with bounds = Some bounds }

     

       154
       154
       +
       

     

       155
       155
       +
       (** Update author *)

     

       156
       156
       +
       let with_author t author = { t with author = Some author }

     

       157
       157
       +
       

     

       158
       158
       +
       (** Update copyright *)

     

       159
       159
       +
       let with_copyright t copyright = { t with copyright = Some copyright }

     

       160
       160
       +
       

     

       161
       161
       +
       (** Add link *)

     

       162
       162
       +
       let add_link t link = { t with links = link :: t.links }

     

       162
       163
        
       

     

       163
       164
        
       (** Add extensions *)

     

       164
       165
        
       let add_extensions t extensions = { t with extensions = extensions @ t.extensions }

+27 -24

lib/gpx/metadata.mli

···

       34
       34
        
         val make_from_floats : minlat:float -> minlon:float -> maxlat:float -> maxlon:float -> (t, string) result

     

       35
       35
        
       

     

       36
       36
        
         (** Get minimum corner coordinates *)

     

       37
       37
       -
         val get_min_coords : t -> Coordinate.t

     

       37
       37
       +
         val min_coords : t -> Coordinate.t

     

       38
       38
        
       

     

       39
       39
        
         (** Get maximum corner coordinates *)

     

       40
       40
       -
         val get_max_coords : t -> Coordinate.t

     

       40
       40
       +
         val max_coords : t -> Coordinate.t

     

       41
       41
        
       

     

       42
       42
        
         (** Get all bounds as tuple *)

     

       43
       43
       -
         val get_bounds : t -> (Coordinate.latitude * Coordinate.longitude * Coordinate.latitude * Coordinate.longitude)

     

       43
       43
       +
         val bounds : t -> (Coordinate.latitude * Coordinate.longitude * Coordinate.latitude * Coordinate.longitude)

     

       44
       44
        
       

     

       45
       45
        
         (** Check if coordinate is within bounds *)

     

       46
       46
        
         val contains : t -> Coordinate.t -> bool

     
···

       67
       67
        
       val make : name:string -> t

     

       68
       68
        
       

     

       69
       69
        
       (** Get name *)

     

       70
       70
       -
       val get_name : t -> string option

     

       70
       70
       +
       val name : t -> string option

     

       71
       71
        
       

     

       72
       72
        
       (** Get description *)  

     

       73
       73
       -
       val get_description : t -> string option

     

       73
       73
       +
       val description : t -> string option

     

       74
       74
        
       

     

       75
       75
        
       (** Get author *)

     

       76
       76
       -
       val get_author : t -> Link.person option

     

       76
       76
       +
       val author : t -> Link.person option

     

       77
       77
        
       

     

       78
       78
        
       (** Get copyright *)

     

       79
       79
       -
       val get_copyright : t -> Link.copyright option

     

       79
       79
       +
       val copyright : t -> Link.copyright option

     

       80
       80
        
       

     

       81
       81
        
       (** Get links *)

     

       82
       82
       -
       val get_links : t -> Link.t list

     

       82
       82
       +
       val links : t -> Link.t list

     

       83
       83
        
       

     

       84
       84
        
       (** Get time *)

     

       85
       85
       -
       val get_time : t -> Ptime.t option

     

       85
       85
       +
       val time : t -> Ptime.t option

     

       86
       86
        
       

     

       87
       87
        
       (** Get keywords *)

     

       88
       88
       -
       val get_keywords : t -> string option

     

       88
       88
       +
       val keywords : t -> string option

     

       89
       89
        
       

     

       90
       90
        
       (** Get bounds *)

     

       91
       91
       -
       val get_bounds : t -> bounds option

     

       91
       91
       +
       val bounds_opt : t -> bounds option

     

       92
       92
        
       

     

       93
       93
       -
       (** Set name *)

     

       94
       94
       -
       val set_name : string -> t -> t

     

       93
       93
       +
       (** Get extensions *)

     

       94
       94
       +
       val extensions : t -> Extension.t list

     

       95
       95
        
       

     

       96
       96
       -
       (** Set description *)

     

       97
       97
       -
       val set_description : string -> t -> t

     

       96
       96
       +
       (** Functional operations for building metadata *)

     

       98
       97
        
       

     

       99
       99
       -
       (** Set author *)

     

       100
       100
       -
       val set_author : Link.person -> t -> t

     

       101
       101
       -
       

     

       102
       102
       -
       (** Functional setters for building metadata *)

     

       103
       103
       -
       

     

       104
       104
       -
       (** Set name *)

     

       98
       98
       +
       (** Update name *)

     

       105
       99
        
       val with_name : t -> string -> t

     

       106
       100
        
       

     

       107
       107
       -
       (** Set description *)

     

       101
       101
       +
       (** Update description *)

     

       108
       102
        
       val with_description : t -> string -> t

     

       109
       103
        
       

     

       110
       110
       -
       (** Set keywords *)

     

       104
       104
       +
       (** Update keywords *)

     

       111
       105
        
       val with_keywords : t -> string -> t

     

       112
       106
        
       

     

       113
       113
       -
       (** Set time *)

     

       107
       107
       +
       (** Update time *)

     

       114
       108
        
       val with_time : t -> Ptime.t option -> t

     

       109
       109
       +
       

     

       110
       110
       +
       (** Update bounds *)

     

       111
       111
       +
       val with_bounds : t -> bounds -> t

     

       112
       112
       +
       

     

       113
       113
       +
       (** Update author *)

     

       114
       114
       +
       val with_author : t -> Link.person -> t

     

       115
       115
       +
       

     

       116
       116
       +
       (** Update copyright *)

     

       117
       117
       +
       val with_copyright : t -> Link.copyright -> t

     

       115
       118
        
       

     

       116
       119
        
       (** Add link *)

     

       117
       120
        
       val add_link : t -> Link.t -> t

+127 -9

lib/gpx/parser.ml

···

       228
       228
        
         let namespace = if ns = "" then None else Some ns in

     

       229
       229
        
         let attributes = List.map (fun ((_, n), v) -> (n, v)) attrs in

     

       230
       230
        
         let* content = parse_extension_content parser in

     

       231
       231
       -
         Ok (Extension.make ~namespace ~name ~attributes ~content ())

     

       231
       231
       +
         Ok (Extension.make ?namespace ~name ~attributes ~content ())

     

       232
       232
        
       

     

       233
       233
        
       and parse_extension_content parser =

     

       234
       234
        
         Buffer.clear parser.text_buffer;

     
···

       290
       290
        
         in

     

       291
       291
        
         

     

       292
       292
        
         let* (version, creator) = find_gpx_root () in

     

       293
       293
       -
         let gpx = Gpx_doc.empty ~creator in

     

       294
       294
       -
         parse_gpx_elements parser (Gpx_doc.with_version gpx version)

     

       293
       293
       +
         let gpx = Doc.empty ~creator in

     

       294
       294
       +
         parse_gpx_elements parser { gpx with version }

     

       295
       295
        
       

     

       296
       296
        
       and parse_gpx_elements parser gpx =

     

       297
       297
        
         let rec loop gpx =

     
···

       301
       301
        
             (match name with

     

       302
       302
        
              | "metadata" ->

     

       303
       303
        
                let* metadata = parse_metadata parser in

     

       304
       304
       -
                loop (Gpx_doc.with_metadata gpx metadata)

     

       304
       304
       +
                loop (Doc.with_metadata gpx metadata)

     

       305
       305
        
              | "wpt" ->

     

       306
       306
        
                let* (lat, lon) = parse_coordinates attrs "wpt" in

     

       307
       307
        
                let* waypoint = parse_waypoint_data parser lat lon in

     

       308
       308
       -
                loop (Gpx_doc.add_waypoint gpx waypoint)

     

       308
       308
       +
                loop (Doc.add_waypoint gpx waypoint)

     

       309
       309
        
              | "rte" ->

     

       310
       310
        
                let* route = parse_route parser in

     

       311
       311
       -
                loop (Gpx_doc.add_route gpx route)

     

       311
       311
       +
                loop (Doc.add_route gpx route)

     

       312
       312
        
              | "trk" ->

     

       313
       313
        
                let* track = parse_track parser in

     

       314
       314
       -
                loop (Gpx_doc.add_track gpx track)

     

       314
       314
       +
                loop (Doc.add_track gpx track)

     

       315
       315
        
              | "extensions" ->

     

       316
       316
        
                let* extensions = parse_extensions parser in

     

       317
       317
       -
                loop (Gpx_doc.add_extensions gpx extensions)

     

       317
       317
       +
                loop (Doc.add_extensions gpx extensions)

     

       318
       318
        
              | _ ->

     

       319
       319
        
                let* _ = skip_element parser in

     

       320
       320
        
                loop gpx)

     
···

       327
       327
        
         in

     

       328
       328
        
         loop gpx

     

       329
       329
        
       

     

       330
       330
       +
       and parse_author parser =

     

       331
       331
       +
         let rec loop name email link =

     

       332
       332
       +
           match Xmlm.input parser.input with

     

       333
       333
       +
           | `El_start ((_, element_name), attrs) ->

     

       334
       334
       +
             parser.current_element <- element_name :: parser.current_element;

     

       335
       335
       +
             (match element_name with

     

       336
       336
       +
              | "name" ->

     

       337
       337
       +
                let* text = parse_text_content parser in

     

       338
       338
       +
                loop (Some text) email link

     

       339
       339
       +
              | "email" ->

     

       340
       340
       +
                let* email_addr = parse_email_attrs attrs in

     

       341
       341
       +
                let* _ = skip_element parser in

     

       342
       342
       +
                loop name (Some email_addr) link  

     

       343
       343
       +
              | "link" ->

     

       344
       344
       +
                let* parsed_link = parse_link parser attrs in

     

       345
       345
       +
                loop name email (Some parsed_link)

     

       346
       346
       +
              | _ ->

     

       347
       347
       +
                let* _ = skip_element parser in

     

       348
       348
       +
                loop name email link)

     

       349
       349
       +
           | `El_end ->

     

       350
       350
       +
             parser.current_element <- List.tl parser.current_element;

     

       351
       351
       +
             Ok (Link.make_person ?name ?email ?link ())

     

       352
       352
       +
           | `Data _ ->

     

       353
       353
       +
             loop name email link

     

       354
       354
       +
           | `Dtd _ ->

     

       355
       355
       +
             loop name email link

     

       356
       356
       +
         in

     

       357
       357
       +
         loop None None None

     

       358
       358
       +
       

     

       359
       359
       +
       and parse_email_attrs attrs =

     

       360
       360
       +
         let get_attr name =

     

       361
       361
       +
           List.find_map (fun ((_, attr_name), value) ->

     

       362
       362
       +
             if attr_name = name then Some value else None

     

       363
       363
       +
           ) attrs

     

       364
       364
       +
         in

     

       365
       365
       +
         match get_attr "id", get_attr "domain" with

     

       366
       366
       +
         | Some id, Some domain -> Ok (id ^ "@" ^ domain)

     

       367
       367
       +
         | _ -> Error (Error.invalid_xml "Missing email id or domain attributes")

     

       368
       368
       +
       

     

       369
       369
       +
       and parse_copyright parser attrs =

     

       370
       370
       +
         let get_attr name =

     

       371
       371
       +
           List.find_map (fun ((_, attr_name), value) ->

     

       372
       372
       +
             if attr_name = name then Some value else None

     

       373
       373
       +
           ) attrs

     

       374
       374
       +
         in

     

       375
       375
       +
         let author = get_attr "author" in

     

       376
       376
       +
         let rec loop year license =

     

       377
       377
       +
           match Xmlm.input parser.input with

     

       378
       378
       +
           | `El_start ((_, element_name), _) ->

     

       379
       379
       +
             parser.current_element <- element_name :: parser.current_element;

     

       380
       380
       +
             (match element_name with

     

       381
       381
       +
              | "year" ->

     

       382
       382
       +
                let* text = parse_text_content parser in

     

       383
       383
       +
                (match parse_int_opt text with

     

       384
       384
       +
                 | Some y -> loop (Some y) license

     

       385
       385
       +
                 | None -> loop year license)

     

       386
       386
       +
              | "license" ->

     

       387
       387
       +
                let* text = parse_text_content parser in

     

       388
       388
       +
                loop year (Some text)

     

       389
       389
       +
              | _ ->

     

       390
       390
       +
                let* _ = skip_element parser in

     

       391
       391
       +
                loop year license)

     

       392
       392
       +
           | `El_end ->

     

       393
       393
       +
             parser.current_element <- List.tl parser.current_element;

     

       394
       394
       +
             (match author with

     

       395
       395
       +
              | Some auth -> Ok (Link.make_copyright ~author:auth ?year ?license ())

     

       396
       396
       +
              | None -> Error (Error.invalid_xml "Missing copyright author attribute"))

     

       397
       397
       +
           | `Data _ ->

     

       398
       398
       +
             loop year license

     

       399
       399
       +
           | `Dtd _ ->

     

       400
       400
       +
             loop year license

     

       401
       401
       +
         in

     

       402
       402
       +
         loop None None

     

       403
       403
       +
       

     

       404
       404
       +
       and parse_bounds parser attrs =

     

       405
       405
       +
         let get_attr name =

     

       406
       406
       +
           List.find_map (fun ((_, attr_name), value) ->

     

       407
       407
       +
             if attr_name = name then Some value else None

     

       408
       408
       +
           ) attrs

     

       409
       409
       +
         in

     

       410
       410
       +
         let minlat_str = get_attr "minlat" in

     

       411
       411
       +
         let minlon_str = get_attr "minlon" in

     

       412
       412
       +
         let maxlat_str = get_attr "maxlat" in

     

       413
       413
       +
         let maxlon_str = get_attr "maxlon" in

     

       414
       414
       +
         

     

       415
       415
       +
         (* Skip content since bounds is a self-closing element *)

     

       416
       416
       +
         let rec skip_bounds_content () =

     

       417
       417
       +
           match Xmlm.input parser.input with

     

       418
       418
       +
           | `El_end -> 

     

       419
       419
       +
               parser.current_element <- List.tl parser.current_element;

     

       420
       420
       +
               Ok ()

     

       421
       421
       +
           | `Data _ -> skip_bounds_content ()

     

       422
       422
       +
           | _ -> skip_bounds_content ()

     

       423
       423
       +
         in

     

       424
       424
       +
         let* () = skip_bounds_content () in

     

       425
       425
       +
         

     

       426
       426
       +
         match minlat_str, minlon_str, maxlat_str, maxlon_str with

     

       427
       427
       +
         | Some minlat, Some minlon, Some maxlat, Some maxlon ->

     

       428
       428
       +
             (match 

     

       429
       429
       +
                Float.of_string_opt minlat, Float.of_string_opt minlon,

     

       430
       430
       +
                Float.of_string_opt maxlat, Float.of_string_opt maxlon

     

       431
       431
       +
              with

     

       432
       432
       +
              | Some minlat_f, Some minlon_f, Some maxlat_f, Some maxlon_f ->

     

       433
       433
       +
                  (match Metadata.Bounds.make_from_floats ~minlat:minlat_f ~minlon:minlon_f ~maxlat:maxlat_f ~maxlon:maxlon_f with

     

       434
       434
       +
                   | Ok bounds -> Ok bounds

     

       435
       435
       +
                   | Error msg -> Error (Error.invalid_xml ("Invalid bounds: " ^ msg)))

     

       436
       436
       +
              | _ -> Error (Error.invalid_xml ("Invalid bounds coordinates")))

     

       437
       437
       +
         | _ -> Error (Error.invalid_xml ("Missing bounds attributes"))

     

       438
       438
       +
       

     

       330
       439
        
       and parse_metadata parser =

     

       331
       440
        
         let metadata = Metadata.empty in

     

       332
       441
        
         let rec loop metadata =

     
···

       349
       458
        
              | "link" ->

     

       350
       459
        
                let* link = parse_link parser attrs in

     

       351
       460
        
                loop (Metadata.add_link metadata link)

     

       461
       461
       +
              | "author" ->

     

       462
       462
       +
                let* author = parse_author parser in

     

       463
       463
       +
                loop (Metadata.with_author metadata author)

     

       464
       464
       +
              | "copyright" ->

     

       465
       465
       +
                let* copyright = parse_copyright parser attrs in

     

       466
       466
       +
                loop (Metadata.with_copyright metadata copyright)

     

       467
       467
       +
              | "bounds" ->

     

       468
       468
       +
                let* bounds = parse_bounds parser attrs in

     

       469
       469
       +
                loop (Metadata.with_bounds metadata bounds)

     

       352
       470
        
              | "extensions" ->

     

       353
       471
        
                let* extensions = parse_extensions parser in

     

       354
       472
        
                loop (Metadata.add_extensions metadata extensions)

     
···

       518
       636
        
       (** Parse from string *)

     

       519
       637
        
       let parse_string ?(validate=false) s =

     

       520
       638
        
         let input = Xmlm.make_input (`String (0, s)) in

     

       521
       521
       -
         parse ~validate input
     

       639
       639
       +
         parse ~validate input

+2 -2

lib/gpx/parser.mli

···

       1
       1
        
       (** GPX streaming parser using xmlm *)

     

       2
       2
        
       

     

       3
       3
        
       (** Parse a GPX document from an xmlm input source *)

     

       4
       4
       -
       val parse : ?validate:bool -> Xmlm.input -> (Gpx_doc.t, Error.t) result

     

       4
       4
       +
       val parse : ?validate:bool -> Xmlm.input -> (Doc.t, Error.t) result

     

       5
       5
        
       

     

       6
       6
        
       (** Parse a GPX document from a string *)

     

       7
       7
       -
       val parse_string : ?validate:bool -> string -> (Gpx_doc.t, Error.t) result
     

       7
       7
       +
       val parse_string : ?validate:bool -> string -> (Doc.t, Error.t) result

+30 -17

lib/gpx/route.ml

···

       33
       33
        
         let make_rtept (lat_f, lon_f) =

     

       34
       34
        
           match Waypoint.make_from_floats ~lat:lat_f ~lon:lon_f () with

     

       35
       35
        
           | Ok wpt -> wpt

     

       36
       36
       -
           | Error e -> failwith e

     

       36
       36
       +
           | Error e -> invalid_arg e

     

       37
       37
        
         in

     

       38
       38
        
         let rtepts = List.map make_rtept coords in

     

       39
       39
        
         { empty with name = Some name; rtepts }

     

       40
       40
        
       

     

       41
       41
        
       (** Get route name *)

     

       42
       42
       -
       let get_name t = t.name

     

       42
       42
       +
       let name t = t.name

     

       43
       43
        
       

     

       44
       44
        
       (** Get route description *)

     

       45
       45
       -
       let get_description t = t.desc

     

       45
       45
       +
       let description t = t.desc

     

       46
       46
       +
       

     

       47
       47
       +
       (** Get route number *)

     

       48
       48
       +
       let number t = t.number

     

       49
       49
       +
       

     

       50
       50
       +
       (** Get route comment *)

     

       51
       51
       +
       let comment t = t.cmt

     

       52
       52
       +
       

     

       53
       53
       +
       (** Get route source *)

     

       54
       54
       +
       let source t = t.src

     

       55
       55
       +
       

     

       56
       56
       +
       (** Get route links *)

     

       57
       57
       +
       let links t = t.links

     

       58
       58
       +
       

     

       59
       59
       +
       (** Get route type *)

     

       60
       60
       +
       let type_ t = t.type_

     

       61
       61
       +
       

     

       62
       62
       +
       (** Get route extensions *)

     

       63
       63
       +
       let extensions t = t.extensions

     

       46
       64
        
       

     

       47
       65
        
       (** Get route points *)

     

       48
       48
       -
       let get_points t = t.rtepts

     

       66
       66
       +
       let points t = t.rtepts

     

       49
       67
        
       

     

       50
       68
        
       (** Get route point count *)

     

       51
       69
        
       let point_count t = List.length t.rtepts

     

       52
       70
        
       

     

       53
       53
       -
       (** Set name *)

     

       54
       54
       -
       let set_name name t = { t with name = Some name }

     

       55
       55
       -
       

     

       56
       56
       -
       (** Set description *)

     

       57
       57
       -
       let set_description desc t = { t with desc = Some desc }

     

       58
       71
        
       

     

       59
       72
        
       (** Clear all points *)

     

       60
       73
        
       let clear_points t = { t with rtepts = [] }

     
···

       105
       118
        
         | [] -> None

     

       106
       119
        
         | p :: _ -> Some p

     

       107
       120
        
       

     

       108
       108
       -
       (** {2 Functional Setters} *)

     

       121
       121
       +
       (** {2 Functional Operations} *)

     

       109
       122
        
       

     

       110
       110
       -
       (** Set name *)

     

       123
       123
       +
       (** Update name *)

     

       111
       124
        
       let with_name t name = { t with name = Some name }

     

       112
       125
        
       

     

       113
       113
       -
       (** Set comment *)

     

       126
       126
       +
       (** Update comment *)

     

       114
       127
        
       let with_comment t cmt = { t with cmt = Some cmt }

     

       115
       128
        
       

     

       116
       116
       -
       (** Set description *)

     

       129
       129
       +
       (** Update description *)

     

       117
       130
        
       let with_description t desc = { t with desc = Some desc }

     

       118
       131
        
       

     

       119
       119
       -
       (** Set source *)

     

       132
       132
       +
       (** Update source *)

     

       120
       133
        
       let with_source t src = { t with src = Some src }

     

       121
       134
        
       

     

       122
       122
       -
       (** Set number *)

     

       135
       135
       +
       (** Update number *)

     

       123
       136
        
       let with_number t number = { t with number = Some number }

     

       124
       137
        
       

     

       125
       125
       -
       (** Set type *)

     

       138
       138
       +
       (** Update type *)

     

       126
       139
        
       let with_type t type_ = { t with type_ = Some type_ }

     

       127
       140
        
       

     

       128
       141
        
       (** Add point *)

     
···

       150
       163
        
       let pp ppf t =

     

       151
       164
        
         match t.name with

     

       152
       165
        
         | Some name -> Format.fprintf ppf "\"%s\" (%d points)" name (point_count t)

     

       153
       153
       -
         | None -> Format.fprintf ppf "(unnamed route, %d points)" (point_count t)
     

       166
       166
       +
         | None -> Format.fprintf ppf "(unnamed route, %d points)" (point_count t)

+31 -19

lib/gpx/route.mli

···

       27
       27
        
       (** Create route from coordinate list.

     

       28
       28
        
           @param name Route name

     

       29
       29
        
           @param coords List of (latitude, longitude) pairs

     

       30
       30
       -
           @raises Failure on invalid coordinates *)

     

       30
       30
       +
           @raises Invalid_argument on invalid coordinates *)

     

       31
       31
        
       val make_from_coords : name:string -> (float * float) list -> t

     

       32
       32
        
       

     

       33
       33
        
       (** {2 Route Properties} *)

     

       34
       34
        
       

     

       35
       35
        
       (** Get route name *)

     

       36
       36
       -
       val get_name : t -> string option

     

       36
       36
       +
       val name : t -> string option

     

       37
       37
        
       

     

       38
       38
        
       (** Get route description *)

     

       39
       39
       -
       val get_description : t -> string option

     

       39
       39
       +
       val description : t -> string option

     

       40
       40
       +
       

     

       41
       41
       +
       (** Get route number *)

     

       42
       42
       +
       val number : t -> int option

     

       43
       43
       +
       

     

       44
       44
       +
       (** Get route comment *)

     

       45
       45
       +
       val comment : t -> string option

     

       46
       46
       +
       

     

       47
       47
       +
       (** Get route source *)

     

       48
       48
       +
       val source : t -> string option

     

       49
       49
       +
       

     

       50
       50
       +
       (** Get route links *)

     

       51
       51
       +
       val links : t -> Link.t list

     

       52
       52
       +
       

     

       53
       53
       +
       (** Get route type *)

     

       54
       54
       +
       val type_ : t -> string option

     

       55
       55
       +
       

     

       56
       56
       +
       (** Get route extensions *)

     

       57
       57
       +
       val extensions : t -> Extension.t list

     

       40
       58
        
       

     

       41
       59
        
       (** Get route points *)

     

       42
       42
       -
       val get_points : t -> point list

     

       60
       60
       +
       val points : t -> point list

     

       43
       61
        
       

     

       44
       62
        
       (** Get route point count *)

     

       45
       63
        
       val point_count : t -> int

     
···

       48
       66
        
       val is_empty : t -> bool

     

       49
       67
        
       

     

       50
       68
        
       (** {2 Route Modification} *)

     

       51
       51
       -
       

     

       52
       52
       -
       (** Set name *)

     

       53
       53
       -
       val set_name : string -> t -> t

     

       54
       54
       -
       

     

       55
       55
       -
       (** Set description *)

     

       56
       56
       -
       val set_description : string -> t -> t

     

       57
       69
        
       

     

       58
       70
        
       (** Clear all points *)

     

       59
       71
        
       val clear_points : t -> t

     
···

       72
       84
        
       (** Get last point *)

     

       73
       85
        
       val last_point : t -> point option

     

       74
       86
        
       

     

       75
       75
       -
       (** {2 Functional Setters} *)

     

       87
       87
       +
       (** {2 Functional Operations} *)

     

       76
       88
        
       

     

       77
       77
       -
       (** Set name *)

     

       89
       89
       +
       (** Update name *)

     

       78
       90
        
       val with_name : t -> string -> t

     

       79
       91
        
       

     

       80
       80
       -
       (** Set comment *)

     

       81
       81
       -
       val with_comment : t -> string -> t  

     

       92
       92
       +
       (** Update comment *)

     

       93
       93
       +
       val with_comment : t -> string -> t

     

       82
       94
        
       

     

       83
       83
       -
       (** Set description *)

     

       95
       95
       +
       (** Update description *)

     

       84
       96
        
       val with_description : t -> string -> t

     

       85
       97
        
       

     

       86
       86
       -
       (** Set source *)

     

       98
       98
       +
       (** Update source *)

     

       87
       99
        
       val with_source : t -> string -> t

     

       88
       100
        
       

     

       89
       89
       -
       (** Set number *)

     

       101
       101
       +
       (** Update number *)

     

       90
       102
        
       val with_number : t -> int -> t

     

       91
       103
        
       

     

       92
       92
       -
       (** Set type *)

     

       104
       104
       +
       (** Update type *)

     

       93
       105
        
       val with_type : t -> string -> t

     

       94
       106
        
       

     

       95
       107
        
       (** Add point *)

     
···

       110
       122
        
       val equal : t -> t -> bool

     

       111
       123
        
       

     

       112
       124
        
       (** Pretty print route *)

     

       113
       113
       -
       val pp : Format.formatter -> t -> unit
     

       125
       125
       +
       val pp : Format.formatter -> t -> unit

+34 -18

lib/gpx/track.ml

···

       38
       38
        
           let make_trkpt (lat_f, lon_f) =

     

       39
       39
        
             match Waypoint.make_from_floats ~lat:lat_f ~lon:lon_f () with

     

       40
       40
        
             | Ok wpt -> wpt

     

       41
       41
       -
             | Error e -> failwith e

     

       41
       41
       +
             | Error e -> invalid_arg e

     

       42
       42
        
           in

     

       43
       43
        
           let trkpts = List.map make_trkpt coords in

     

       44
       44
        
           { trkpts; extensions = [] }

     

       45
       45
        
       

     

       46
       46
        
         (** Get points *)

     

       47
       47
       -
         let get_points t = t.trkpts

     

       47
       47
       +
         let points t = t.trkpts

     

       48
       48
        
       

     

       49
       49
        
         (** Get point count *)

     

       50
       50
        
         let point_count t = List.length t.trkpts

     

       51
       51
       +
       

     

       52
       52
       +
         (** Get extensions *)

     

       53
       53
       +
         let extensions (seg : segment) = seg.extensions

     

       51
       54
        
       

     

       52
       55
        
         (** Add point *)

     

       53
       56
        
         let add_point t point = { t with trkpts = t.trkpts @ [point] }

     
···

       104
       107
        
         { empty with name = Some name; trksegs = [segment] }

     

       105
       108
        
       

     

       106
       109
        
       (** Get track name *)

     

       107
       107
       -
       let get_name t = t.name

     

       110
       110
       +
       let name t = t.name

     

       108
       111
        
       

     

       109
       112
        
       (** Get track description *)

     

       110
       110
       -
       let get_description t = t.desc

     

       113
       113
       +
       let description t = t.desc

     

       114
       114
       +
       

     

       115
       115
       +
       (** Get track comment *)

     

       116
       116
       +
       let comment t = t.cmt

     

       117
       117
       +
       

     

       118
       118
       +
       (** Get track source *)

     

       119
       119
       +
       let source t = t.src

     

       120
       120
       +
       

     

       121
       121
       +
       (** Get track links *)

     

       122
       122
       +
       let links t = t.links

     

       123
       123
       +
       

     

       124
       124
       +
       (** Get track number *)

     

       125
       125
       +
       let number t = t.number

     

       126
       126
       +
       

     

       127
       127
       +
       (** Get track type *)

     

       128
       128
       +
       let type_ t = t.type_

     

       129
       129
       +
       

     

       130
       130
       +
       (** Get track extensions *)

     

       131
       131
       +
       let extensions t = t.extensions

     

       111
       132
        
       

     

       112
       133
        
       (** Get track segments *)

     

       113
       113
       -
       let get_segments t = t.trksegs

     

       134
       134
       +
       let segments t = t.trksegs

     

       114
       135
        
       

     

       115
       136
        
       (** Get segment count *)

     

       116
       137
        
       let segment_count t = List.length t.trksegs

     
···

       119
       140
        
       let point_count t = 

     

       120
       141
        
         List.fold_left (fun acc seg -> acc + Segment.point_count seg) 0 t.trksegs

     

       121
       142
        
       

     

       122
       122
       -
       (** Set name *)

     

       123
       123
       -
       let set_name name t = { t with name = Some name }

     

       124
       124
       -
       

     

       125
       125
       -
       (** Set description *)

     

       126
       126
       -
       let set_description desc t = { t with desc = Some desc }

     

       127
       143
        
       

     

       128
       144
        
       (** Clear all segments *)

     

       129
       145
        
       let clear_segments t = { t with trksegs = [] }

     
···

       172
       188
        
       (** Test track equality *)

     

       173
       189
        
       let equal t1 t2 = compare t1 t2 = 0

     

       174
       190
        
       

     

       175
       175
       -
       (** {2 Functional Setters} *)

     

       191
       191
       +
       (** {2 Functional Operations} *)

     

       176
       192
        
       

     

       177
       177
       -
       (** Set name *)

     

       193
       193
       +
       (** Update name *)

     

       178
       194
        
       let with_name t name = { t with name = Some name }

     

       179
       195
        
       

     

       180
       180
       -
       (** Set comment *)

     

       196
       196
       +
       (** Update comment *)

     

       181
       197
        
       let with_comment t cmt = { t with cmt = Some cmt }

     

       182
       198
        
       

     

       183
       183
       -
       (** Set description *)

     

       199
       199
       +
       (** Update description *)

     

       184
       200
        
       let with_description t desc = { t with desc = Some desc }

     

       185
       201
        
       

     

       186
       186
       -
       (** Set source *)

     

       202
       202
       +
       (** Update source *)

     

       187
       203
        
       let with_source t src = { t with src = Some src }

     

       188
       204
        
       

     

       189
       189
       -
       (** Set number *)

     

       205
       205
       +
       (** Update number *)

     

       190
       206
        
       let with_number t number = { t with number = Some number }

     

       191
       207
        
       

     

       192
       192
       -
       (** Set type *)

     

       208
       208
       +
       (** Update type *)

     

       193
       209
        
       let with_type t type_ = { t with type_ = Some type_ }

     

       194
       210
        
       

     

       195
       211
        
       (** Add segment *)

     
···

       207
       223
        
         | Some name -> Format.fprintf ppf "\"%s\" (%d segments, %d points)" 

     

       208
       224
        
                          name (segment_count t) (point_count t)

     

       209
       225
        
         | None -> Format.fprintf ppf "(unnamed track, %d segments, %d points)" 

     

       210
       210
       -
                     (segment_count t) (point_count t)
     

       226
       226
       +
                     (segment_count t) (point_count t)

+34 -19

lib/gpx/track.mli

···

       34
       34
        
         val make : point list -> t

     

       35
       35
        
       

     

       36
       36
        
         (** Create segment from coordinate list.

     

       37
       37
       -
             @raises Failure on invalid coordinates *)

     

       37
       37
       +
             @raises Invalid_argument on invalid coordinates *)

     

       38
       38
        
         val make_from_coords : (float * float) list -> t

     

       39
       39
        
       

     

       40
       40
        
         (** Get points *)

     

       41
       41
       -
         val get_points : t -> point list

     

       41
       41
       +
         val points : t -> point list

     

       42
       42
        
       

     

       43
       43
        
         (** Get point count *)

     

       44
       44
        
         val point_count : t -> int

     

       45
       45
       +
       

     

       46
       46
       +
         (** Get extensions *)

     

       47
       47
       +
         val extensions : t -> Extension.t list

     

       45
       48
        
       

     

       46
       49
        
         (** Add point *)

     

       47
       50
        
         val add_point : t -> point -> t

     
···

       91
       94
        
       (** {2 Track Properties} *)

     

       92
       95
        
       

     

       93
       96
        
       (** Get track name *)

     

       94
       94
       -
       val get_name : t -> string option

     

       97
       97
       +
       val name : t -> string option

     

       95
       98
        
       

     

       96
       99
        
       (** Get track description *)

     

       97
       97
       -
       val get_description : t -> string option

     

       100
       100
       +
       val description : t -> string option

     

       101
       101
       +
       

     

       102
       102
       +
       (** Get track comment *)

     

       103
       103
       +
       val comment : t -> string option

     

       104
       104
       +
       

     

       105
       105
       +
       (** Get track source *)

     

       106
       106
       +
       val source : t -> string option

     

       107
       107
       +
       

     

       108
       108
       +
       (** Get track links *)

     

       109
       109
       +
       val links : t -> Link.t list

     

       110
       110
       +
       

     

       111
       111
       +
       (** Get track number *)

     

       112
       112
       +
       val number : t -> int option

     

       113
       113
       +
       

     

       114
       114
       +
       (** Get track type *)

     

       115
       115
       +
       val type_ : t -> string option

     

       116
       116
       +
       

     

       117
       117
       +
       (** Get track extensions *)

     

       118
       118
       +
       val extensions : t -> Extension.t list

     

       98
       119
        
       

     

       99
       120
        
       (** Get track segments *)

     

       100
       100
       -
       val get_segments : t -> segment list

     

       121
       121
       +
       val segments : t -> segment list

     

       101
       122
        
       

     

       102
       123
        
       (** Get segment count *)

     

       103
       124
        
       val segment_count : t -> int

     
···

       109
       130
        
       val is_empty : t -> bool

     

       110
       131
        
       

     

       111
       132
        
       (** {2 Track Modification} *)

     

       112
       112
       -
       

     

       113
       113
       -
       (** Set name *)

     

       114
       114
       -
       val set_name : string -> t -> t

     

       115
       115
       -
       

     

       116
       116
       -
       (** Set description *)

     

       117
       117
       -
       val set_description : string -> t -> t

     

       118
       133
        
       

     

       119
       134
        
       (** Clear all segments *)

     

       120
       135
        
       val clear_segments : t -> t

     
···

       144
       159
        
       (** Test track equality *)

     

       145
       160
        
       val equal : t -> t -> bool

     

       146
       161
        
       

     

       147
       147
       -
       (** {2 Functional Setters} *)

     

       162
       162
       +
       (** {2 Functional Operations} *)

     

       148
       163
        
       

     

       149
       149
       -
       (** Set name *)

     

       164
       164
       +
       (** Update name *)

     

       150
       165
        
       val with_name : t -> string -> t

     

       151
       166
        
       

     

       152
       152
       -
       (** Set comment *)

     

       167
       167
       +
       (** Update comment *)

     

       153
       168
        
       val with_comment : t -> string -> t

     

       154
       169
        
       

     

       155
       155
       -
       (** Set description *)

     

       170
       170
       +
       (** Update description *)

     

       156
       171
        
       val with_description : t -> string -> t

     

       157
       172
        
       

     

       158
       158
       -
       (** Set source *)

     

       173
       173
       +
       (** Update source *)

     

       159
       174
        
       val with_source : t -> string -> t

     

       160
       175
        
       

     

       161
       161
       -
       (** Set number *)

     

       176
       176
       +
       (** Update number *)

     

       162
       177
        
       val with_number : t -> int -> t

     

       163
       178
        
       

     

       164
       164
       -
       (** Set type *)

     

       179
       179
       +
       (** Update type *)

     

       165
       180
        
       val with_type : t -> string -> t

     

       166
       181
        
       

     

       167
       182
        
       (** Add segment *)

     
···

       174
       189
        
       val add_extensions : t -> Extension.t list -> t

     

       175
       190
        
       

     

       176
       191
        
       (** Pretty print track *)

     

       177
       177
       -
       val pp : Format.formatter -> t -> unit
     

       192
       192
       +
       val pp : Format.formatter -> t -> unit

+23 -23

lib/gpx/validate.ml

···

       29
       29
        
         let issues = ref [] in

     

       30
       30
        
         

     

       31
       31
        
         (* Check for negative satellite count *)

     

       32
       32
       -
         (match Waypoint.get_sat wpt with

     

       32
       32
       +
         (match Waypoint.sat wpt with

     

       33
       33
        
          | Some sat when sat < 0 ->

     

       34
       34
        
            issues := make_warning ~location ("Negative satellite count: " ^ string_of_int sat) :: !issues

     

       35
       35
        
          | _ -> ());

     
···

       44
       44
        
           | _ -> ()

     

       45
       45
        
         in

     

       46
       46
        
         

     

       47
       47
       -
         check_precision "hdop" (Waypoint.get_hdop wpt);

     

       48
       48
       -
         check_precision "vdop" (Waypoint.get_vdop wpt);

     

       49
       49
       -
         check_precision "pdop" (Waypoint.get_pdop wpt);

     

       47
       47
       +
         check_precision "hdop" (Waypoint.hdop wpt);

     

       48
       48
       +
         check_precision "vdop" (Waypoint.vdop wpt);

     

       49
       49
       +
         check_precision "pdop" (Waypoint.pdop wpt);

     

       50
       50
        
         

     

       51
       51
        
         (* Check elevation reasonableness *)

     

       52
       52
       -
         (match Waypoint.get_elevation wpt with

     

       52
       52
       +
         (match Waypoint.elevation wpt with

     

       53
       53
        
          | Some ele when ele < -15000.0 ->

     

       54
       54
        
            issues := make_warning ~location (Printf.sprintf "Very low elevation: %.2f m" ele) :: !issues

     

       55
       55
        
          | Some ele when ele > 15000.0 ->

     
···

       57
       57
        
          | _ -> ());

     

       58
       58
        
         

     

       59
       59
        
         (* Check DGPS age *)

     

       60
       60
       -
         (match Waypoint.get_ageofdgpsdata wpt with

     

       60
       60
       +
         (match Waypoint.ageofdgpsdata wpt with

     

       61
       61
        
          | Some age when age < 0.0 ->

     

       62
       62
        
            issues := make_error ~location "Negative DGPS age" :: !issues

     

       63
       63
        
          | _ -> ());

     
···

       69
       69
        
         let issues = ref [] in

     

       70
       70
        
         let location = "bounds" in

     

       71
       71
        
         

     

       72
       72
       -
         let (minlat, minlon, maxlat, maxlon) = Metadata.Bounds.get_bounds bounds in

     

       72
       72
       +
         let (minlat, minlon, maxlat, maxlon) = Metadata.Bounds.bounds bounds in

     

       73
       73
        
         if Coordinate.latitude_to_float minlat >= Coordinate.latitude_to_float maxlat then

     

       74
       74
        
           issues := make_error ~location "minlat must be less than maxlat" :: !issues;

     

       75
       75
        
         

     
···

       83
       83
        
         let issues = ref [] in

     

       84
       84
        
         

     

       85
       85
        
         (* Validate bounds if present *)

     

       86
       86
       -
         (match Metadata.get_bounds metadata with

     

       86
       86
       +
         (match Metadata.bounds_opt metadata with

     

       87
       87
        
          | Some bounds -> issues := validate_bounds bounds @ !issues

     

       88
       88
        
          | None -> ());

     

       89
       89
        
         

     

       90
       90
        
         (* Check for reasonable copyright year *)

     

       91
       91
       -
         (match Metadata.get_copyright metadata with

     

       91
       91
       +
         (match Metadata.copyright metadata with

     

       92
       92
        
          | Some copyright ->

     

       93
       93
       -
            (match Link.get_copyright_year copyright with

     

       93
       93
       +
            (match Link.copyright_year copyright with

     

       94
       94
        
             | Some year when year < 1900 || year > 2100 ->

     

       95
       95
        
               issues := make_warning ~location:"metadata.copyright" 

     

       96
       96
        
                 (Printf.sprintf "Unusual copyright year: %d" year) :: !issues

     
···

       105
       105
        
         let location = "route" in

     

       106
       106
        
         

     

       107
       107
        
         (* Check for empty route *)

     

       108
       108
       -
         let points = Route.get_points route in

     

       108
       108
       +
         let points = Route.points route in

     

       109
       109
        
         if points = [] then

     

       110
       110
        
           issues := make_warning ~location "Route has no points" :: !issues;

     

       111
       111
        
         

     
···

       123
       123
        
         let location = Printf.sprintf "track.trkseg[%d]" seg_idx in

     

       124
       124
        
         

     

       125
       125
        
         (* Check for empty segment *)

     

       126
       126
       -
         let points = Track.Segment.get_points trkseg in

     

       126
       126
       +
         let points = Track.Segment.points trkseg in

     

       127
       127
        
         if points = [] then

     

       128
       128
        
           issues := make_warning ~location "Track segment has no points" :: !issues;

     

       129
       129
        
         

     
···

       137
       137
        
         let rec check_time_order prev_time = function

     

       138
       138
        
           | [] -> ()

     

       139
       139
        
           | trkpt :: rest ->

     

       140
       140
       -
             (match (prev_time, Waypoint.get_time trkpt) with

     

       140
       140
       +
             (match (prev_time, Waypoint.time trkpt) with

     

       141
       141
        
              | (Some prev, Some curr) when Ptime.compare prev curr > 0 ->

     

       142
       142
        
                issues := make_warning ~location "Track points not in chronological order" :: !issues

     

       143
       143
        
              | _ -> ());

     

       144
       144
       -
             check_time_order (Waypoint.get_time trkpt) rest

     

       144
       144
       +
             check_time_order (Waypoint.time trkpt) rest

     

       145
       145
        
         in

     

       146
       146
        
         check_time_order None points;

     

       147
       147
        
         

     
···

       153
       153
        
         let location = "track" in

     

       154
       154
        
         

     

       155
       155
        
         (* Check for empty track *)

     

       156
       156
       -
         let segments = Track.get_segments track in

     

       156
       156
       +
         let segments = Track.segments track in

     

       157
       157
        
         if segments = [] then

     

       158
       158
        
           issues := make_warning ~location "Track has no segments" :: !issues;

     

       159
       159
        
         

     
···

       169
       169
        
         let issues = ref [] in

     

       170
       170
        
         

     

       171
       171
        
         (* Check GPX version *)

     

       172
       172
       -
         let version = Gpx_doc.get_version gpx in

     

       172
       172
       +
         let version = Doc.version gpx in

     

       173
       173
        
         if version <> "1.0" && version <> "1.1" then

     

       174
       174
        
           issues := make_error ~location:"gpx" 

     

       175
       175
        
             (Printf.sprintf "Unsupported GPX version: %s (supported: 1.0, 1.1)" version) :: !issues

     
···

       178
       178
        
             "GPX 1.0 detected - consider upgrading to GPX 1.1 for better compatibility" :: !issues;

     

       179
       179
        
         

     

       180
       180
        
         (* Check for empty creator *)

     

       181
       181
       -
         let creator = Gpx_doc.get_creator gpx in

     

       181
       181
       +
         let creator = Doc.creator gpx in

     

       182
       182
        
         if String.trim creator = "" then

     

       183
       183
        
           issues := make_error ~location:"gpx" "Creator cannot be empty" :: !issues;

     

       184
       184
        
         

     

       185
       185
        
         (* Validate metadata *)

     

       186
       186
       -
         (match Gpx_doc.get_metadata gpx with

     

       186
       186
       +
         (match Doc.metadata gpx with

     

       187
       187
        
          | Some metadata -> issues := validate_metadata metadata @ !issues

     

       188
       188
        
          | None -> ());

     

       189
       189
        
         

     

       190
       190
        
         (* Validate waypoints *)

     

       191
       191
       -
         let waypoints = Gpx_doc.get_waypoints gpx in

     

       191
       191
       +
         let waypoints = Doc.waypoints gpx in

     

       192
       192
        
         List.iteri (fun i wpt ->

     

       193
       193
        
           let location = Printf.sprintf "waypoint[%d]" i in

     

       194
       194
        
           issues := validate_waypoint_data wpt location @ !issues

     

       195
       195
        
         ) waypoints;

     

       196
       196
        
         

     

       197
       197
        
         (* Validate routes *)

     

       198
       198
       -
         let routes = Gpx_doc.get_routes gpx in

     

       198
       198
       +
         let routes = Doc.routes gpx in

     

       199
       199
        
         List.iteri (fun _i route ->

     

       200
       200
        
           issues := validate_route route @ !issues

     

       201
       201
        
         ) routes;

     

       202
       202
        
         

     

       203
       203
        
         (* Validate tracks *)

     

       204
       204
       -
         let tracks = Gpx_doc.get_tracks gpx in

     

       204
       204
       +
         let tracks = Doc.tracks gpx in

     

       205
       205
        
         List.iteri (fun _i track ->

     

       206
       206
        
           issues := validate_track track @ !issues

     

       207
       207
        
         ) tracks;

     
···

       221
       221
        
         result.is_valid

     

       222
       222
        
       

     

       223
       223
        
       (** Get only error messages *)

     

       224
       224
       -
       let get_errors gpx =

     

       224
       224
       +
       let errors gpx =

     

       225
       225
        
         let result = validate_gpx gpx in

     

       226
       226
        
         List.filter (fun issue -> issue.level = `Error) result.issues

     

       227
       227
        
       

     

       228
       228
        
       (** Get only warning messages *)

     

       229
       229
       -
       let get_warnings gpx =

     

       229
       229
       +
       let warnings gpx =

     

       230
       230
        
         let result = validate_gpx gpx in

     

       231
       231
        
         List.filter (fun issue -> issue.level = `Warning) result.issues

     

       232
       232

+4 -4

lib/gpx/validate.mli

···

       14
       14
        
       }

     

       15
       15
        
       

     

       16
       16
        
       (** Validate a complete GPX document *)

     

       17
       17
       -
       val validate_gpx : Gpx_doc.t -> validation_result

     

       17
       17
       +
       val validate_gpx : Doc.t -> validation_result

     

       18
       18
        
       

     

       19
       19
        
       (** Quick validation - returns true if document is valid *)

     

       20
       20
       -
       val is_valid : Gpx_doc.t -> bool

     

       20
       20
       +
       val is_valid : Doc.t -> bool

     

       21
       21
        
       

     

       22
       22
        
       (** Get only error messages *)

     

       23
       23
       -
       val get_errors : Gpx_doc.t -> validation_issue list

     

       23
       23
       +
       val errors : Doc.t -> validation_issue list

     

       24
       24
        
       

     

       25
       25
        
       (** Get only warning messages *)

     

       26
       26
       -
       val get_warnings : Gpx_doc.t -> validation_issue list

     

       26
       26
       +
       val warnings : Doc.t -> validation_issue list

     

       27
       27
        
       

     

       28
       28
        
       (** Format validation issue for display *)

     

       29
       29
        
       val format_issue : validation_issue -> string

+39 -53

lib/gpx/waypoint.ml

···

       86
       86
        
         | Error e, _ | _, Error e -> Error e

     

       87
       87
        
       

     

       88
       88
        
       (** Get coordinate pair *)

     

       89
       89
       -
       let get_coordinate t = Coordinate.make t.lat t.lon

     

       89
       89
       +
       let coordinate t = Coordinate.make t.lat t.lon

     

       90
       90
        
       

     

       91
       91
        
       (** Get latitude *)

     

       92
       92
       -
       let get_lat t = t.lat

     

       92
       92
       +
       let lat t = t.lat

     

       93
       93
        
       

     

       94
       94
        
       (** Get longitude *)

     

       95
       95
       -
       let get_lon t = t.lon

     

       95
       95
       +
       let lon t = t.lon

     

       96
       96
        
       

     

       97
       97
        
       (** Get coordinate as float pair *)

     

       98
       98
        
       let to_floats t = (Coordinate.latitude_to_float t.lat, Coordinate.longitude_to_float t.lon)

     

       99
       99
        
       

     

       100
       100
        
       (** Get elevation *)

     

       101
       101
       -
       let get_elevation t = t.ele

     

       101
       101
       +
       let elevation t = t.ele

     

       102
       102
        
       

     

       103
       103
        
       (** Get time *)

     

       104
       104
       -
       let get_time t = t.time

     

       104
       104
       +
       let time t = t.time

     

       105
       105
        
       

     

       106
       106
        
       (** Get name *)

     

       107
       107
       -
       let get_name t = t.name

     

       107
       107
       +
       let name t = t.name

     

       108
       108
        
       

     

       109
       109
        
       (** Get description *)

     

       110
       110
       -
       let get_description t = t.desc

     

       110
       110
       +
       let description t = t.desc

     

       111
       111
        
       

     

       112
       112
        
       (** Get comment *)

     

       113
       113
       -
       let get_comment t = t.cmt

     

       113
       113
       +
       let comment t = t.cmt

     

       114
       114
        
       

     

       115
       115
        
       (** Get source *)

     

       116
       116
       -
       let get_source t = t.src

     

       116
       116
       +
       let source t = t.src

     

       117
       117
        
       

     

       118
       118
        
       (** Get symbol *)

     

       119
       119
       -
       let get_symbol t = t.sym

     

       119
       119
       +
       let symbol t = t.sym

     

       120
       120
        
       

     

       121
       121
        
       (** Get type *)

     

       122
       122
       -
       let get_type t = t.type_

     

       122
       122
       +
       let type_ t = t.type_

     

       123
       123
        
       

     

       124
       124
        
       (** Get fix type *)

     

       125
       125
       -
       let get_fix t = t.fix

     

       125
       125
       +
       let fix t = t.fix

     

       126
       126
        
       

     

       127
       127
        
       (** Get satellite count *)

     

       128
       128
       -
       let get_sat t = t.sat

     

       128
       128
       +
       let sat t = t.sat

     

       129
       129
        
       

     

       130
       130
        
       (** Get horizontal dilution of precision *)

     

       131
       131
       -
       let get_hdop t = t.hdop

     

       131
       131
       +
       let hdop t = t.hdop

     

       132
       132
        
       

     

       133
       133
        
       (** Get vertical dilution of precision *)

     

       134
       134
       -
       let get_vdop t = t.vdop

     

       134
       134
       +
       let vdop t = t.vdop

     

       135
       135
        
       

     

       136
       136
        
       (** Get position dilution of precision *)

     

       137
       137
       -
       let get_pdop t = t.pdop

     

       137
       137
       +
       let pdop t = t.pdop

     

       138
       138
        
       

     

       139
       139
        
       (** Get magnetic variation *)

     

       140
       140
       -
       let get_magvar t = t.magvar

     

       140
       140
       +
       let magvar t = t.magvar

     

       141
       141
        
       

     

       142
       142
        
       (** Get geoid height *)

     

       143
       143
       -
       let get_geoidheight t = t.geoidheight

     

       143
       143
       +
       let geoidheight t = t.geoidheight

     

       144
       144
        
       

     

       145
       145
        
       (** Get age of DGPS data *)

     

       146
       146
       -
       let get_ageofdgpsdata t = t.ageofdgpsdata

     

       146
       146
       +
       let ageofdgpsdata t = t.ageofdgpsdata

     

       147
       147
        
       

     

       148
       148
        
       (** Get DGPS ID *)

     

       149
       149
       -
       let get_dgpsid t = t.dgpsid

     

       149
       149
       +
       let dgpsid t = t.dgpsid

     

       150
       150
        
       

     

       151
       151
        
       (** Get links *)

     

       152
       152
       -
       let get_links t = t.links

     

       152
       152
       +
       let links t = t.links

     

       153
       153
        
       

     

       154
       154
        
       (** Get extensions *)

     

       155
       155
       -
       let get_extensions t = t.extensions

     

       156
       156
       -
       

     

       157
       157
       -
       (** Set name *)

     

       158
       158
       -
       let set_name name t = { t with name = Some name }

     

       159
       159
       -
       

     

       160
       160
       -
       (** Set description *)

     

       161
       161
       -
       let set_description desc t = { t with desc = Some desc }

     

       162
       162
       -
       

     

       163
       163
       -
       (** Set elevation *)

     

       164
       164
       -
       let set_elevation ele t = { t with ele = Some ele }

     

       165
       165
       -
       

     

       166
       166
       -
       (** Set time *)

     

       167
       167
       -
       let set_time time t = { t with time = Some time }

     

       155
       155
       +
       let extensions t = t.extensions

     

       168
       156
        
       

     

       169
       169
       -
       (** Functional setters for building waypoints *)

     

       170
       170
       -
       

     

       171
       171
       -
       (** Set elevation *)

     

       157
       157
       +
       (** Update elevation *)

     

       172
       158
        
       let with_elevation t ele = { t with ele = Some ele }

     

       173
       159
        
       

     

       174
       174
       -
       (** Set time *)

     

       160
       160
       +
       (** Update time *)

     

       175
       161
        
       let with_time t time = { t with time }

     

       176
       162
        
       

     

       177
       177
       -
       (** Set name *)

     

       163
       163
       +
       (** Update name *)

     

       178
       164
        
       let with_name t name = { t with name = Some name }

     

       179
       165
        
       

     

       180
       180
       -
       (** Set comment *)

     

       166
       166
       +
       (** Update comment *)

     

       181
       167
        
       let with_comment t cmt = { t with cmt = Some cmt }

     

       182
       168
        
       

     

       183
       183
       -
       (** Set description *)

     

       169
       169
       +
       (** Update description *)

     

       184
       170
        
       let with_description t desc = { t with desc = Some desc }

     

       185
       171
        
       

     

       186
       186
       -
       (** Set source *)

     

       172
       172
       +
       (** Update source *)

     

       187
       173
        
       let with_source t src = { t with src = Some src }

     

       188
       174
        
       

     

       189
       189
       -
       (** Set symbol *)

     

       175
       175
       +
       (** Update symbol *)

     

       190
       176
        
       let with_symbol t sym = { t with sym = Some sym }

     

       191
       177
        
       

     

       192
       192
       -
       (** Set type *)

     

       178
       178
       +
       (** Update type *)

     

       193
       179
        
       let with_type t type_ = { t with type_ = Some type_ }

     

       194
       180
        
       

     

       195
       195
       -
       (** Set fix type *)

     

       181
       181
       +
       (** Update fix *)

     

       196
       182
        
       let with_fix t fix = { t with fix }

     

       197
       183
        
       

     

       198
       198
       -
       (** Set satellite count *)

     

       184
       184
       +
       (** Update satellite count *)

     

       199
       185
        
       let with_sat t sat = { t with sat = Some sat }

     

       200
       186
        
       

     

       201
       201
       -
       (** Set horizontal dilution of precision *)

     

       187
       187
       +
       (** Update HDOP *)

     

       202
       188
        
       let with_hdop t hdop = { t with hdop = Some hdop }

     

       203
       189
        
       

     

       204
       204
       -
       (** Set vertical dilution of precision *)

     

       190
       190
       +
       (** Update VDOP *)

     

       205
       191
        
       let with_vdop t vdop = { t with vdop = Some vdop }

     

       206
       192
        
       

     

       207
       207
       -
       (** Set position dilution of precision *)

     

       193
       193
       +
       (** Update PDOP *)

     

       208
       194
        
       let with_pdop t pdop = { t with pdop = Some pdop }

     

       209
       195
        
       

     

       210
       210
       -
       (** Set magnetic variation *)

     

       196
       196
       +
       (** Update magnetic variation *)

     

       211
       197
        
       let with_magvar t magvar = { t with magvar = Some magvar }

     

       212
       198
        
       

     

       213
       213
       -
       (** Set geoid height *)

     

       199
       199
       +
       (** Update geoid height *)

     

       214
       200
        
       let with_geoidheight t geoidheight = { t with geoidheight = Some geoidheight }

     

       215
       201
        
       

     

       216
       216
       -
       (** Set age of DGPS data *)

     

       202
       202
       +
       (** Update age of DGPS data *)

     

       217
       203
        
       let with_ageofdgpsdata t ageofdgpsdata = { t with ageofdgpsdata = Some ageofdgpsdata }

     

       218
       204
        
       

     

       219
       219
       -
       (** Set DGPS ID *)

     

       205
       205
       +
       (** Update DGPS ID *)

     

       220
       206
        
       let with_dgpsid t dgpsid = { t with dgpsid = Some dgpsid }

     

       221
       207
        
       

     

       222
       208
        
       (** Add link *)

+40 -52

lib/gpx/waypoint.mli

···

       56
       56
        
       val make_from_floats : lat:float -> lon:float -> ?name:string -> ?desc:string -> unit -> (t, string) result

     

       57
       57
        
       

     

       58
       58
        
       (** Get coordinate pair *)

     

       59
       59
       -
       val get_coordinate : t -> Coordinate.t

     

       59
       59
       +
       val coordinate : t -> Coordinate.t

     

       60
       60
        
       

     

       61
       61
        
       (** Get latitude *)

     

       62
       62
       -
       val get_lat : t -> Coordinate.latitude

     

       62
       62
       +
       val lat : t -> Coordinate.latitude

     

       63
       63
        
       

     

       64
       64
        
       (** Get longitude *)

     

       65
       65
       -
       val get_lon : t -> Coordinate.longitude

     

       65
       65
       +
       val lon : t -> Coordinate.longitude

     

       66
       66
        
       

     

       67
       67
        
       (** Get coordinate as float pair *)

     

       68
       68
        
       val to_floats : t -> float * float

     

       69
       69
        
       

     

       70
       70
        
       (** Get elevation *)

     

       71
       71
       -
       val get_elevation : t -> float option

     

       71
       71
       +
       val elevation : t -> float option

     

       72
       72
        
       

     

       73
       73
        
       (** Get time *)

     

       74
       74
       -
       val get_time : t -> Ptime.t option

     

       74
       74
       +
       val time : t -> Ptime.t option

     

       75
       75
        
       

     

       76
       76
        
       (** Get name *)

     

       77
       77
       -
       val get_name : t -> string option

     

       77
       77
       +
       val name : t -> string option

     

       78
       78
        
       

     

       79
       79
        
       (** Get description *)

     

       80
       80
       -
       val get_description : t -> string option

     

       80
       80
       +
       val description : t -> string option

     

       81
       81
        
       

     

       82
       82
        
       (** Get comment *)

     

       83
       83
       -
       val get_comment : t -> string option

     

       83
       83
       +
       val comment : t -> string option

     

       84
       84
        
       

     

       85
       85
        
       (** Get source *)

     

       86
       86
       -
       val get_source : t -> string option

     

       86
       86
       +
       val source : t -> string option

     

       87
       87
        
       

     

       88
       88
        
       (** Get symbol *)

     

       89
       89
       -
       val get_symbol : t -> string option

     

       89
       89
       +
       val symbol : t -> string option

     

       90
       90
        
       

     

       91
       91
        
       (** Get type *)

     

       92
       92
       -
       val get_type : t -> string option

     

       92
       92
       +
       val type_ : t -> string option

     

       93
       93
        
       

     

       94
       94
        
       (** Get fix type *)

     

       95
       95
       -
       val get_fix : t -> fix_type option

     

       95
       95
       +
       val fix : t -> fix_type option

     

       96
       96
        
       

     

       97
       97
        
       (** Get satellite count *)

     

       98
       98
       -
       val get_sat : t -> int option

     

       98
       98
       +
       val sat : t -> int option

     

       99
       99
        
       

     

       100
       100
        
       (** Get horizontal dilution of precision *)

     

       101
       101
       -
       val get_hdop : t -> float option

     

       101
       101
       +
       val hdop : t -> float option

     

       102
       102
        
       

     

       103
       103
        
       (** Get vertical dilution of precision *)

     

       104
       104
       -
       val get_vdop : t -> float option

     

       104
       104
       +
       val vdop : t -> float option

     

       105
       105
        
       

     

       106
       106
        
       (** Get position dilution of precision *)

     

       107
       107
       -
       val get_pdop : t -> float option

     

       107
       107
       +
       val pdop : t -> float option

     

       108
       108
        
       

     

       109
       109
        
       (** Get magnetic variation *)

     

       110
       110
       -
       val get_magvar : t -> Coordinate.degrees option

     

       110
       110
       +
       val magvar : t -> Coordinate.degrees option

     

       111
       111
        
       

     

       112
       112
        
       (** Get geoid height *)

     

       113
       113
       -
       val get_geoidheight : t -> float option

     

       113
       113
       +
       val geoidheight : t -> float option

     

       114
       114
        
       

     

       115
       115
        
       (** Get age of DGPS data *)

     

       116
       116
       -
       val get_ageofdgpsdata : t -> float option

     

       116
       116
       +
       val ageofdgpsdata : t -> float option

     

       117
       117
        
       

     

       118
       118
        
       (** Get DGPS ID *)

     

       119
       119
       -
       val get_dgpsid : t -> int option

     

       119
       119
       +
       val dgpsid : t -> int option

     

       120
       120
        
       

     

       121
       121
        
       (** Get links *)

     

       122
       122
       -
       val get_links : t -> Link.t list

     

       122
       122
       +
       val links : t -> Link.t list

     

       123
       123
        
       

     

       124
       124
        
       (** Get extensions *)

     

       125
       125
       -
       val get_extensions : t -> Extension.t list

     

       126
       126
       -
       

     

       127
       127
       -
       (** Set name *)

     

       128
       128
       -
       val set_name : string -> t -> t

     

       129
       129
       -
       

     

       130
       130
       -
       (** Set description *)

     

       131
       131
       -
       val set_description : string -> t -> t

     

       132
       132
       -
       

     

       133
       133
       -
       (** Set elevation *)

     

       134
       134
       -
       val set_elevation : float -> t -> t

     

       125
       125
       +
       val extensions : t -> Extension.t list

     

       135
       126
        
       

     

       136
       136
       -
       (** Set time *)

     

       137
       137
       -
       val set_time : Ptime.t -> t -> t

     

       127
       127
       +
       (** Functional operations for building waypoints *)

     

       138
       128
        
       

     

       139
       139
       -
       (** Functional setters for building waypoints *)

     

       140
       140
       -
       

     

       141
       141
       -
       (** Set elevation *)

     

       129
       129
       +
       (** Update elevation *)

     

       142
       130
        
       val with_elevation : t -> float -> t

     

       143
       131
        
       

     

       144
       144
       -
       (** Set time *)

     

       132
       132
       +
       (** Update time *)

     

       145
       133
        
       val with_time : t -> Ptime.t option -> t

     

       146
       134
        
       

     

       147
       147
       -
       (** Set name *)

     

       135
       135
       +
       (** Update name *)

     

       148
       136
        
       val with_name : t -> string -> t

     

       149
       137
        
       

     

       150
       150
       -
       (** Set comment *)

     

       138
       138
       +
       (** Update comment *)

     

       151
       139
        
       val with_comment : t -> string -> t

     

       152
       140
        
       

     

       153
       153
       -
       (** Set description *)

     

       141
       141
       +
       (** Update description *)

     

       154
       142
        
       val with_description : t -> string -> t

     

       155
       143
        
       

     

       156
       156
       -
       (** Set source *)

     

       144
       144
       +
       (** Update source *)

     

       157
       145
        
       val with_source : t -> string -> t

     

       158
       146
        
       

     

       159
       159
       -
       (** Set symbol *)

     

       147
       147
       +
       (** Update symbol *)

     

       160
       148
        
       val with_symbol : t -> string -> t

     

       161
       149
        
       

     

       162
       162
       -
       (** Set type *)

     

       150
       150
       +
       (** Update type *)

     

       163
       151
        
       val with_type : t -> string -> t

     

       164
       152
        
       

     

       165
       165
       -
       (** Set fix type *)

     

       153
       153
       +
       (** Update fix *)

     

       166
       154
        
       val with_fix : t -> fix_type option -> t

     

       167
       155
        
       

     

       168
       168
       -
       (** Set satellite count *)

     

       156
       156
       +
       (** Update satellite count *)

     

       169
       157
        
       val with_sat : t -> int -> t

     

       170
       158
        
       

     

       171
       171
       -
       (** Set horizontal dilution of precision *)

     

       159
       159
       +
       (** Update HDOP *)

     

       172
       160
        
       val with_hdop : t -> float -> t

     

       173
       161
        
       

     

       174
       174
       -
       (** Set vertical dilution of precision *)

     

       162
       162
       +
       (** Update VDOP *)

     

       175
       163
        
       val with_vdop : t -> float -> t

     

       176
       164
        
       

     

       177
       177
       -
       (** Set position dilution of precision *)

     

       165
       165
       +
       (** Update PDOP *)

     

       178
       166
        
       val with_pdop : t -> float -> t

     

       179
       167
        
       

     

       180
       180
       -
       (** Set magnetic variation *)

     

       168
       168
       +
       (** Update magnetic variation *)

     

       181
       169
        
       val with_magvar : t -> Coordinate.degrees -> t

     

       182
       170
        
       

     

       183
       183
       -
       (** Set geoid height *)

     

       171
       171
       +
       (** Update geoid height *)

     

       184
       172
        
       val with_geoidheight : t -> float -> t

     

       185
       173
        
       

     

       186
       186
       -
       (** Set age of DGPS data *)

     

       174
       174
       +
       (** Update age of DGPS data *)

     

       187
       175
        
       val with_ageofdgpsdata : t -> float -> t

     

       188
       176
        
       

     

       189
       189
       -
       (** Set DGPS ID *)

     

       177
       177
       +
       (** Update DGPS ID *)

     

       190
       178
        
       val with_dgpsid : t -> int -> t

     

       191
       179
        
       

     

       192
       180
        
       (** Add link *)

+242 -29

lib/gpx/writer.ml

···

       1
       1
       -
       (** GPX XML writer using xmlm *)

     

       1
       1
       +
       (** GPX XML writer with complete spec coverage *)

     

       2
       2
        
       

     

       3
       3
        
       (** Result binding operators *)

     

       4
       4
        
       let (let*) = Result.bind

     
···

       35
       35
        
         | Some text -> output_text_element writer name text

     

       36
       36
        
         | None -> Ok ()

     

       37
       37
        
       

     

       38
       38
       +
       let output_optional_float_element writer name = function

     

       39
       39
       +
         | Some value -> output_text_element writer name (Printf.sprintf "%.6f" value)

     

       40
       40
       +
         | None -> Ok ()

     

       41
       41
       +
       

     

       42
       42
       +
       let output_optional_degrees_element writer name = function

     

       43
       43
       +
         | Some degrees -> output_text_element writer name (Printf.sprintf "%.6f" (Coordinate.degrees_to_float degrees))

     

       44
       44
       +
         | None -> Ok ()

     

       45
       45
       +
       

     

       46
       46
       +
       let output_optional_int_element writer name = function

     

       47
       47
       +
         | Some value -> output_text_element writer name (string_of_int value)

     

       48
       48
       +
         | None -> Ok ()

     

       49
       49
       +
       

     

       50
       50
       +
       let output_optional_time_element writer name = function

     

       51
       51
       +
         | Some time -> output_text_element writer name (Ptime.to_rfc3339 time)

     

       52
       52
       +
         | None -> Ok ()

     

       53
       53
       +
       

     

       54
       54
       +
       let output_optional_fix_element writer name = function

     

       55
       55
       +
         | Some fix_type -> output_text_element writer name (Waypoint.fix_type_to_string fix_type)

     

       56
       56
       +
         | None -> Ok ()

     

       57
       57
       +
       

     

       58
       58
       +
       (** Write link elements *)

     

       59
       59
       +
       let output_link writer link =

     

       60
       60
       +
         let href = Link.href link in

     

       61
       61
       +
         let attrs = [(("", "href"), href)] in

     

       62
       62
       +
         let* () = output_element_start writer "link" attrs in

     

       63
       63
       +
         let* () = output_optional_text_element writer "text" (Link.text link) in

     

       64
       64
       +
         let* () = output_optional_text_element writer "type" (Link.type_ link) in

     

       65
       65
       +
         output_element_end writer

     

       66
       66
       +
       

     

       67
       67
       +
       let output_links writer links =

     

       68
       68
       +
         let rec write_links = function

     

       69
       69
       +
           | [] -> Ok ()

     

       70
       70
       +
           | link :: rest ->

     

       71
       71
       +
               let* () = output_link writer link in

     

       72
       72
       +
               write_links rest

     

       73
       73
       +
         in

     

       74
       74
       +
         write_links links

     

       75
       75
       +
       

     

       76
       76
       +
       (** Write person (author) element *)

     

       77
       77
       +
       let output_person writer person =

     

       78
       78
       +
         let* () = output_element_start writer "author" [] in

     

       79
       79
       +
         let* () = output_optional_text_element writer "name" (Link.person_name person) in

     

       80
       80
       +
         let* () = match Link.person_email person with

     

       81
       81
       +
           | Some email ->

     

       82
       82
       +
               (* Parse email into id and domain *)

     

       83
       83
       +
               (match String.index_opt email '@' with

     

       84
       84
       +
                | Some at_pos ->

     

       85
       85
       +
                    let id = String.sub email 0 at_pos in

     

       86
       86
       +
                    let domain = String.sub email (at_pos + 1) (String.length email - at_pos - 1) in

     

       87
       87
       +
                    let attrs = [(("", "id"), id); (("", "domain"), domain)] in

     

       88
       88
       +
                    let* () = output_element_start writer "email" attrs in

     

       89
       89
       +
                    output_element_end writer

     

       90
       90
       +
                | None ->

     

       91
       91
       +
                    (* Invalid email format, skip *)

     

       92
       92
       +
                    Ok ())

     

       93
       93
       +
           | None -> Ok ()

     

       94
       94
       +
         in

     

       95
       95
       +
         let* () = match Link.person_link person with

     

       96
       96
       +
           | Some link -> output_link writer link

     

       97
       97
       +
           | None -> Ok ()

     

       98
       98
       +
         in

     

       99
       99
       +
         output_element_end writer

     

       100
       100
       +
       

     

       101
       101
       +
       (** Write copyright element *)

     

       102
       102
       +
       let output_copyright writer copyright =

     

       103
       103
       +
         let author = Link.copyright_author copyright in

     

       104
       104
       +
         let attrs = [(("", "author"), author)] in

     

       105
       105
       +
         let* () = output_element_start writer "copyright" attrs in

     

       106
       106
       +
         let* () = output_optional_int_element writer "year" (Link.copyright_year copyright) in

     

       107
       107
       +
         let* () = output_optional_text_element writer "license" (Link.copyright_license copyright) in

     

       108
       108
       +
         output_element_end writer

     

       109
       109
       +
       

     

       110
       110
       +
       (** Write bounds element *)

     

       111
       111
       +
       let output_bounds writer bounds =

     

       112
       112
       +
         let (minlat, minlon, maxlat, maxlon) = Metadata.Bounds.bounds bounds in

     

       113
       113
       +
         let attrs = [

     

       114
       114
       +
           (("", "minlat"), Printf.sprintf "%.6f" (Coordinate.latitude_to_float minlat));

     

       115
       115
       +
           (("", "minlon"), Printf.sprintf "%.6f" (Coordinate.longitude_to_float minlon));

     

       116
       116
       +
           (("", "maxlat"), Printf.sprintf "%.6f" (Coordinate.latitude_to_float maxlat));

     

       117
       117
       +
           (("", "maxlon"), Printf.sprintf "%.6f" (Coordinate.longitude_to_float maxlon));

     

       118
       118
       +
         ] in

     

       119
       119
       +
         let* () = output_element_start writer "bounds" attrs in

     

       120
       120
       +
         output_element_end writer

     

       121
       121
       +
       

     

       122
       122
       +
       (** Write extensions element *)

     

       123
       123
       +
       let output_extensions writer extensions =

     

       124
       124
       +
         if extensions = [] then Ok ()

     

       125
       125
       +
         else

     

       126
       126
       +
           let* () = output_element_start writer "extensions" [] in

     

       127
       127
       +
           (* For now, skip writing extension content - would need full extension serialization *)

     

       128
       128
       +
           output_element_end writer

     

       129
       129
       +
       

     

       130
       130
       +
       (** Write metadata element *)

     

       131
       131
       +
       let output_metadata writer metadata =

     

       132
       132
       +
         let* () = output_element_start writer "metadata" [] in

     

       133
       133
       +
         let* () = output_optional_text_element writer "name" (Metadata.name metadata) in

     

       134
       134
       +
         let* () = output_optional_text_element writer "desc" (Metadata.description metadata) in

     

       135
       135
       +
         let* () = match Metadata.author metadata with

     

       136
       136
       +
           | Some author -> output_person writer author

     

       137
       137
       +
           | None -> Ok ()

     

       138
       138
       +
         in

     

       139
       139
       +
         let* () = match Metadata.copyright metadata with

     

       140
       140
       +
           | Some copyright -> output_copyright writer copyright

     

       141
       141
       +
           | None -> Ok ()

     

       142
       142
       +
         in

     

       143
       143
       +
         let* () = output_links writer (Metadata.links metadata) in

     

       144
       144
       +
         let* () = output_optional_time_element writer "time" (Metadata.time metadata) in

     

       145
       145
       +
         let* () = output_optional_text_element writer "keywords" (Metadata.keywords metadata) in

     

       146
       146
       +
         let* () = match Metadata.bounds_opt metadata with

     

       147
       147
       +
           | Some bounds -> output_bounds writer bounds

     

       148
       148
       +
           | None -> Ok ()

     

       149
       149
       +
         in

     

       150
       150
       +
         let* () = output_extensions writer (Metadata.extensions metadata) in

     

       151
       151
       +
         output_element_end writer

     

       152
       152
       +
       

     

       153
       153
       +
       (** Write waypoint elements (used for wpt, rtept, trkpt) *)

     

       154
       154
       +
       let output_waypoint_data writer waypoint =

     

       155
       155
       +
         let* () = output_optional_float_element writer "ele" (Waypoint.elevation waypoint) in

     

       156
       156
       +
         let* () = output_optional_time_element writer "time" (Waypoint.time waypoint) in

     

       157
       157
       +
         let* () = output_optional_degrees_element writer "magvar" (Waypoint.magvar waypoint) in

     

       158
       158
       +
         let* () = output_optional_float_element writer "geoidheight" (Waypoint.geoidheight waypoint) in

     

       159
       159
       +
         let* () = output_optional_text_element writer "name" (Waypoint.name waypoint) in

     

       160
       160
       +
         let* () = output_optional_text_element writer "cmt" (Waypoint.comment waypoint) in

     

       161
       161
       +
         let* () = output_optional_text_element writer "desc" (Waypoint.description waypoint) in

     

       162
       162
       +
         let* () = output_optional_text_element writer "src" (Waypoint.source waypoint) in

     

       163
       163
       +
         let* () = output_links writer (Waypoint.links waypoint) in

     

       164
       164
       +
         let* () = output_optional_text_element writer "sym" (Waypoint.symbol waypoint) in

     

       165
       165
       +
         let* () = output_optional_text_element writer "type" (Waypoint.type_ waypoint) in

     

       166
       166
       +
         let* () = output_optional_fix_element writer "fix" (Waypoint.fix waypoint) in

     

       167
       167
       +
         let* () = output_optional_int_element writer "sat" (Waypoint.sat waypoint) in

     

       168
       168
       +
         let* () = output_optional_float_element writer "hdop" (Waypoint.hdop waypoint) in

     

       169
       169
       +
         let* () = output_optional_float_element writer "vdop" (Waypoint.vdop waypoint) in

     

       170
       170
       +
         let* () = output_optional_float_element writer "pdop" (Waypoint.pdop waypoint) in

     

       171
       171
       +
         let* () = output_optional_float_element writer "ageofdgpsdata" (Waypoint.ageofdgpsdata waypoint) in

     

       172
       172
       +
         let* () = output_optional_int_element writer "dgpsid" (Waypoint.dgpsid waypoint) in

     

       173
       173
       +
         output_extensions writer (Waypoint.extensions waypoint)

     

       174
       174
       +
       

     

       175
       175
       +
       (** Write waypoints *)

     

       176
       176
       +
       let output_waypoints writer waypoints =

     

       177
       177
       +
         let rec write_waypoints = function

     

       178
       178
       +
           | [] -> Ok ()

     

       179
       179
       +
           | wpt :: rest ->

     

       180
       180
       +
               let lat = Coordinate.latitude_to_float (Waypoint.lat wpt) in

     

       181
       181
       +
               let lon = Coordinate.longitude_to_float (Waypoint.lon wpt) in

     

       182
       182
       +
               let attrs = [

     

       183
       183
       +
                 (("", "lat"), Printf.sprintf "%.6f" lat);

     

       184
       184
       +
                 (("", "lon"), Printf.sprintf "%.6f" lon);

     

       185
       185
       +
               ] in

     

       186
       186
       +
               let* () = output_element_start writer "wpt" attrs in

     

       187
       187
       +
               let* () = output_waypoint_data writer wpt in

     

       188
       188
       +
               let* () = output_element_end writer in

     

       189
       189
       +
               write_waypoints rest

     

       190
       190
       +
         in

     

       191
       191
       +
         write_waypoints waypoints

     

       192
       192
       +
       

     

       193
       193
       +
       (** Write route points *)

     

       194
       194
       +
       let output_route_points writer points element_name =

     

       195
       195
       +
         let rec write_points = function

     

       196
       196
       +
           | [] -> Ok ()

     

       197
       197
       +
           | pt :: rest ->

     

       198
       198
       +
               let lat = Coordinate.latitude_to_float (Waypoint.lat pt) in

     

       199
       199
       +
               let lon = Coordinate.longitude_to_float (Waypoint.lon pt) in

     

       200
       200
       +
               let attrs = [

     

       201
       201
       +
                 (("", "lat"), Printf.sprintf "%.6f" lat);

     

       202
       202
       +
                 (("", "lon"), Printf.sprintf "%.6f" lon);

     

       203
       203
       +
               ] in

     

       204
       204
       +
               let* () = output_element_start writer element_name attrs in

     

       205
       205
       +
               let* () = output_waypoint_data writer pt in

     

       206
       206
       +
               let* () = output_element_end writer in

     

       207
       207
       +
               write_points rest

     

       208
       208
       +
         in

     

       209
       209
       +
         write_points points

     

       210
       210
       +
       

     

       211
       211
       +
       (** Write routes *)

     

       212
       212
       +
       let output_routes writer routes =

     

       213
       213
       +
         let rec write_routes = function

     

       214
       214
       +
           | [] -> Ok ()

     

       215
       215
       +
           | route :: rest ->

     

       216
       216
       +
               let* () = output_element_start writer "rte" [] in

     

       217
       217
       +
               let* () = output_optional_text_element writer "name" (Route.name route) in

     

       218
       218
       +
               let* () = output_optional_text_element writer "cmt" (Route.comment route) in

     

       219
       219
       +
               let* () = output_optional_text_element writer "desc" (Route.description route) in

     

       220
       220
       +
               let* () = output_optional_text_element writer "src" (Route.source route) in

     

       221
       221
       +
               let* () = output_links writer (Route.links route) in

     

       222
       222
       +
               let* () = output_optional_int_element writer "number" (Route.number route) in

     

       223
       223
       +
               let* () = output_optional_text_element writer "type" (Route.type_ route) in

     

       224
       224
       +
               let* () = output_extensions writer (Route.extensions route) in

     

       225
       225
       +
               let* () = output_route_points writer (Route.points route) "rtept" in

     

       226
       226
       +
               let* () = output_element_end writer in

     

       227
       227
       +
               write_routes rest

     

       228
       228
       +
         in

     

       229
       229
       +
         write_routes routes

     

       230
       230
       +
       

     

       231
       231
       +
       (** Write track segments *)

     

       232
       232
       +
       let output_track_segments writer segments =

     

       233
       233
       +
         let rec write_segments = function

     

       234
       234
       +
           | [] -> Ok ()

     

       235
       235
       +
           | seg :: rest ->

     

       236
       236
       +
               let* () = output_element_start writer "trkseg" [] in

     

       237
       237
       +
               let* () = output_route_points writer (Track.Segment.points seg) "trkpt" in

     

       238
       238
       +
               let* () = output_extensions writer (Track.Segment.extensions seg) in

     

       239
       239
       +
               let* () = output_element_end writer in

     

       240
       240
       +
               write_segments rest

     

       241
       241
       +
         in

     

       242
       242
       +
         write_segments segments

     

       243
       243
       +
       

     

       244
       244
       +
       (** Write tracks *)

     

       245
       245
       +
       let output_tracks writer tracks =

     

       246
       246
       +
         let rec write_tracks = function

     

       247
       247
       +
           | [] -> Ok ()

     

       248
       248
       +
           | track :: rest ->

     

       249
       249
       +
               let* () = output_element_start writer "trk" [] in

     

       250
       250
       +
               let* () = output_optional_text_element writer "name" (Track.name track) in

     

       251
       251
       +
               let* () = output_optional_text_element writer "cmt" (Track.comment track) in

     

       252
       252
       +
               let* () = output_optional_text_element writer "desc" (Track.description track) in

     

       253
       253
       +
               let* () = output_optional_text_element writer "src" (Track.source track) in

     

       254
       254
       +
               let* () = output_links writer (Track.links track) in

     

       255
       255
       +
               let* () = output_optional_int_element writer "number" (Track.number track) in

     

       256
       256
       +
               let* () = output_optional_text_element writer "type" (Track.type_ track) in

     

       257
       257
       +
               let* () = output_extensions writer (Track.extensions track) in

     

       258
       258
       +
               let* () = output_track_segments writer (Track.segments track) in

     

       259
       259
       +
               let* () = output_element_end writer in

     

       260
       260
       +
               write_tracks rest

     

       261
       261
       +
         in

     

       262
       262
       +
         write_tracks tracks

     

       263
       263
       +
       

     

       38
       264
        
       (** Write a complete GPX document *)

     

       39
       265
        
       let write ?(validate=false) output gpx =

     

       40
       266
        
         let writer = Xmlm.make_output output in

     
···

       42
       268
        
         let result =

     

       43
       269
        
           try

     

       44
       270
        
             (* Write XML declaration and GPX root element *)

     

       45
       45
       -
             let version = Gpx_doc.get_version gpx in

     

       46
       46
       -
             let creator = Gpx_doc.get_creator gpx in

     

       271
       271
       +
             let version = Doc.version gpx in

     

       272
       272
       +
             let creator = Doc.creator gpx in

     

       47
       273
        
             let attrs = [

     

       48
       274
        
               (("", "version"), version);

     

       49
       275
        
               (("", "creator"), creator);

     
···

       55
       281
        
             let* () = output_element_start writer "gpx" attrs in

     

       56
       282
        
             

     

       57
       283
        
             (* Write metadata if present *)

     

       58
       58
       -
             let* () = match Gpx_doc.get_metadata gpx with

     

       59
       59
       -
              | Some metadata ->

     

       60
       60
       -
                let* () = output_element_start writer "metadata" [] in

     

       61
       61
       -
                (* Write basic metadata fields *)

     

       62
       62
       -
                let* () = output_optional_text_element writer "name" (Metadata.get_name metadata) in

     

       63
       63
       -
                let* () = output_optional_text_element writer "desc" (Metadata.get_description metadata) in

     

       64
       64
       -
                let* () = output_optional_text_element writer "keywords" (Metadata.get_keywords metadata) in

     

       65
       65
       -
                output_element_end writer

     

       66
       66
       -
              | None -> Ok ()

     

       284
       284
       +
             let* () = match Doc.metadata gpx with

     

       285
       285
       +
               | Some metadata -> output_metadata writer metadata

     

       286
       286
       +
               | None -> Ok ()

     

       67
       287
        
             in

     

       68
       288
        
             

     

       69
       289
        
             (* Write waypoints *)

     

       70
       70
       -
             let waypoints = Gpx_doc.get_waypoints gpx in

     

       71
       71
       -
             let rec write_waypoints = function

     

       72
       72
       -
               | [] -> Ok ()

     

       73
       73
       -
               | wpt :: rest ->

     

       74
       74
       -
                 let lat = Coordinate.latitude_to_float (Waypoint.get_lat wpt) in

     

       75
       75
       -
                 let lon = Coordinate.longitude_to_float (Waypoint.get_lon wpt) in

     

       76
       76
       -
                 let attrs = [

     

       77
       77
       -
                   (("", "lat"), Printf.sprintf "%.6f" lat);

     

       78
       78
       -
                   (("", "lon"), Printf.sprintf "%.6f" lon);

     

       79
       79
       -
                 ] in

     

       80
       80
       -
                 let* () = output_element_start writer "wpt" attrs in

     

       81
       81
       -
                 let* () = output_optional_text_element writer "name" (Waypoint.get_name wpt) in

     

       82
       82
       -
                 let* () = output_optional_text_element writer "desc" (Waypoint.get_description wpt) in

     

       83
       83
       -
                 let* () = output_element_end writer in

     

       84
       84
       -
                 write_waypoints rest

     

       85
       85
       -
             in

     

       86
       86
       -
             let* () = write_waypoints waypoints in

     

       290
       290
       +
             let* () = output_waypoints writer (Doc.waypoints gpx) in

     

       291
       291
       +
             

     

       292
       292
       +
             (* Write routes *)

     

       293
       293
       +
             let* () = output_routes writer (Doc.routes gpx) in

     

       294
       294
       +
             

     

       295
       295
       +
             (* Write tracks *)

     

       296
       296
       +
             let* () = output_tracks writer (Doc.tracks gpx) in

     

       297
       297
       +
             

     

       298
       298
       +
             (* Write root-level extensions *)

     

       299
       299
       +
             let* () = output_extensions writer (Doc.extensions gpx) in

     

       87
       300
        
             

     

       88
       301
        
             output_element_end writer

     

       89
       302

+2 -2

lib/gpx/writer.mli

···

       1
       1
        
       (** GPX streaming writer using xmlm *)

     

       2
       2
        
       

     

       3
       3
        
       (** Write a GPX document to an xmlm output destination *)

     

       4
       4
       -
       val write : ?validate:bool -> Xmlm.dest -> Gpx_doc.t -> (unit, Error.t) result

     

       4
       4
       +
       val write : ?validate:bool -> Xmlm.dest -> Doc.t -> (unit, Error.t) result

     

       5
       5
        
       

     

       6
       6
        
       (** Write a GPX document to a string *)

     

       7
       7
       -
       val write_string : ?validate:bool -> Gpx_doc.t -> (string, Error.t) result
     

       7
       7
       +
       val write_string : ?validate:bool -> Doc.t -> (string, Error.t) result

+1 -1

lib/gpx_eio/dune

···

       2
       2
        
        (public_name mlgpx.eio)

     

       3
       3
        
        (name gpx_eio)

     

       4
       4
        
        (libraries eio xmlm ptime gpx)

     

       5
       5
       -
        (modules gpx_io gpx_eio))
     

       5
       5
       +
        (modules gpx_io gpx_eio))

+6 -71

lib/gpx_eio/gpx_eio.ml

···

       1
       1
       -
       (** High-level Eio API for GPX operations *)

     

       1
       1
       +
       (** Eio API for GPX operations *)

     

       2
       2
        
       

     

       3
       3
       -
       (* I/O module *)

     

       4
       3
        
       module IO = Gpx_io

     

       5
       5
       -
       

     

       6
       6
       -
       (** Convenience functions for common operations *)

     

       7
       4
        
       

     

       8
       5
        
       (** Read and parse GPX file *)

     

       9
       6
        
       let read ?(validate=false) ~fs path = IO.read_file ~validate ~fs path

     
···

       20
       17
        
       (** Write GPX to Eio sink *)

     

       21
       18
        
       let to_sink ?(validate=false) sink gpx = IO.write_sink ~validate sink gpx

     

       22
       19
        
       

     

       23
       23
       -
       (** Create simple waypoint *)

     

       24
       24
       -
       let make_waypoint ~fs:_ ~lat ~lon ?name ?desc () =

     

       25
       25
       -
         match (Gpx.Coordinate.latitude lat, Gpx.Coordinate.longitude lon) with

     

       26
       26
       -
         | (Ok lat, Ok lon) ->

     

       27
       27
       -
           let wpt = Gpx.Waypoint.make lat lon in

     

       28
       28
       -
           Gpx.Waypoint.with_name wpt (Option.value name ~default:"") |>

     

       29
       29
       -
           fun wpt -> Gpx.Waypoint.with_description wpt (Option.value desc ~default:"")

     

       30
       30
       -
         | (Error e, _) | (_, Error e) -> failwith ("Invalid coordinate: " ^ e)

     

       31
       31
       -
       

     

       32
       32
       -
       (** Create simple track from coordinate list *)

     

       33
       33
       -
       let make_track_from_coords ~fs:_ ~name coords = 

     

       34
       34
       -
         Gpx.Track.make_from_coords ~name coords

     

       35
       35
       -
       

     

       36
       36
       -
       (** Create simple route from coordinate list *)

     

       37
       37
       -
       let make_route_from_coords ~fs:_ ~name coords = 

     

       38
       38
       -
         Gpx.Route.make_from_coords ~name coords

     

       39
       39
       -
       

     

       40
       40
       -
       (** Extract coordinates from waypoints *)

     

       41
       41
       -
       let waypoint_coords wpt = Gpx.Waypoint.to_floats wpt

     

       42
       42
       -
       

     

       43
       43
       -
       (** Extract coordinates from track *)

     

       44
       44
       -
       let track_coords trk = Gpx.Track.to_coords trk

     

       45
       45
       -
       

     

       46
       46
       -
       (** Extract coordinates from route *)

     

       47
       47
       -
       let route_coords rte = Gpx.Route.to_coords rte

     

       48
       48
       -
       

     

       49
       49
       -
       (** Count total points in GPX *)

     

       50
       50
       -
       let count_points gpx = 

     

       51
       51
       -
         let waypoints = Gpx.Gpx_doc.get_waypoints gpx in

     

       52
       52
       -
         let routes = Gpx.Gpx_doc.get_routes gpx in  

     

       53
       53
       -
         let tracks = Gpx.Gpx_doc.get_tracks gpx in

     

       54
       54
       -
         List.length waypoints + 

     

       55
       55
       -
         List.fold_left (fun acc r -> acc + List.length (Gpx.Route.get_points r)) 0 routes +

     

       56
       56
       -
         List.fold_left (fun acc t -> acc + Gpx.Track.point_count t) 0 tracks

     

       57
       57
       -
       

     

       58
       58
       -
       (** Get GPX statistics *)

     

       59
       59
       -
       type gpx_stats = {

     

       60
       60
       -
         waypoint_count : int;

     

       61
       61
       -
         route_count : int;

     

       62
       62
       -
         track_count : int;

     

       63
       63
       -
         total_points : int;

     

       64
       64
       -
         has_elevation : bool;

     

       65
       65
       -
         has_time : bool;

     

       66
       66
       -
       }

     

       67
       67
       -
       

     

       68
       68
       -
       let get_stats gpx =

     

       69
       69
       -
         let waypoints = Gpx.Gpx_doc.get_waypoints gpx in

     

       70
       70
       -
         let routes = Gpx.Gpx_doc.get_routes gpx in  

     

       71
       71
       -
         let tracks = Gpx.Gpx_doc.get_tracks gpx in

     

       72
       72
       -
         {

     

       73
       73
       -
           waypoint_count = List.length waypoints;

     

       74
       74
       -
           route_count = List.length routes;

     

       75
       75
       -
           track_count = List.length tracks;  

     

       76
       76
       -
           total_points = count_points gpx;

     

       77
       77
       -
           has_elevation = List.exists (fun w -> Gpx.Waypoint.get_elevation w <> None) waypoints;

     

       78
       78
       -
           has_time = List.exists (fun w -> Gpx.Waypoint.get_time w <> None) waypoints;

     

       79
       79
       -
         }

     

       80
       80
       -
       

     

       81
       20
        
       (** Pretty print GPX statistics *)

     

       82
       82
       -
       let print_stats gpx =

     

       83
       83
       -
         let stats = get_stats gpx in

     

       84
       84
       -
         Printf.printf "GPX Statistics:\\n";

     

       85
       85
       -
         Printf.printf "  Waypoints: %d\\n" stats.waypoint_count;

     

       86
       86
       -
         Printf.printf "  Routes: %d\\n" stats.route_count;

     

       87
       87
       -
         Printf.printf "  Tracks: %d\\n" stats.track_count;

     

       88
       88
       -
         Printf.printf "  Total Points: %d\\n" stats.total_points;

     

       89
       89
       -
         Printf.printf "  Has Elevation: %b\\n" stats.has_elevation;

     

       90
       90
       -
         Printf.printf "  Has Time: %b\\n" stats.has_time
     

       21
       21
       +
       let print_stats sink gpx =

     

       22
       22
       +
         let buf = Buffer.create 256 in

     

       23
       23
       +
         let fmt = Format.formatter_of_buffer buf in

     

       24
       24
       +
         Format.fprintf fmt "%a@?" Gpx.Doc.pp_stats gpx;

     

       25
       25
       +
         Eio.Flow.copy_string (Buffer.contents buf) sink

+11 -74

lib/gpx_eio/gpx_eio.mli

···

       1
       1
       -
       (** {1 GPX Eio - High-level Eio API for GPX operations}

     

       1
       1
       +
       (** {1 Eio API for GPX operations}

     

       2
       2
        
       

     

       3
       3
       -
           This module provides a high-level API for GPX operations using Eio's 

     

       3
       3
       +
           This module provides a direct-style API for GPX operations using Eio's 

     

       4
       4
        
           effects-based concurrent I/O system. It offers convenient functions

     

       5
       5
        
           for common GPX operations while maintaining structured concurrency.

     

       6
       6
        
       

     
···

       13
       13
        
               let fs = Eio.Stdenv.fs env in

     

       14
       14
        
               

     

       15
       15
        
               (* Create a GPX document *)

     

       16
       16
       -
               let lat = Gpx.latitude 37.7749 |> Result.get_ok in

     

       17
       17
       -
               let lon = Gpx.longitude (-122.4194) |> Result.get_ok in

     

       18
       18
       -
               let wpt = make_waypoint fs ~lat:(Gpx.latitude_to_float lat) ~lon:(Gpx.longitude_to_float lon) ~name:"San Francisco" () in

     

       19
       19
       -
               let gpx = Gpx.make_gpx ~creator:"eio-example" in

     

       20
       20
       -
               let gpx = { gpx with waypoints = [wpt] } in

     

       16
       16
       +
               let lat = Gpx.Coordinate.latitude 37.7749 |> Result.get_ok in

     

       17
       17
       +
               let lon = Gpx.Coordinate.longitude (-122.4194) |> Result.get_ok in

     

       18
       18
       +
               let wpt = Gpx.Waypoint.make lat lon |> Gpx.Waypoint.with_name "San Francisco" in

     

       19
       19
       +
               let gpx = Gpx.make_gpx ~creator:"eio-example" |> Gpx.Doc.add_waypoint wpt in

     

       21
       20
        
               

     

       22
       21
        
               (* Write with validation *)

     

       23
       22
        
               write ~validate:true fs "output.gpx" gpx;

     

       24
       23
        
               

     

       25
       24
        
               (* Read it back *)

     

       26
       25
        
               let gpx2 = read ~validate:true fs "output.gpx" in

     

       27
       27
       -
               Printf.printf "Read %d waypoints\n" (List.length gpx2.waypoints)

     

       26
       26
       +
               Printf.printf "Read %d waypoints\n" (List.length (Gpx.Doc.waypoints gpx2))

     

       28
       27
        
       

     

       29
       28
        
             let () = Eio_main.run main

     

       30
       29
        
           ]}

     
···

       36
       35
        
       

     

       37
       36
        
       (** {2 Convenience File Operations}

     

       38
       37
        
       

     

       39
       39
       -
           These functions provide simple file I/O with the filesystem from [Eio.Stdenv.fs]. *)

     

       38
       38
       +
           These functions provide simple file I/O with the filesystem from {!Eio.Stdenv.fs}. *)

     

       40
       39
        
       

     

       41
       40
        
       (** Read and parse GPX file.

     

       42
       41
        
           @param fs Filesystem capability

     
···

       81
       80
        
           @raises Gpx.Gpx_error on write failure *)

     

       82
       81
        
       val to_sink : ?validate:bool -> [> Eio.Flow.sink_ty ] Eio.Resource.t -> Gpx.t -> unit

     

       83
       82
        
       

     

       84
       84
       -
       (** {2 Utility Functions} *)

     

       85
       85
       -
       

     

       86
       86
       -
       (** Create simple waypoint with coordinates.

     

       87
       87
       -
           @param fs Filesystem capability (unused, for API consistency)

     

       88
       88
       -
           @param lat Latitude in degrees

     

       89
       89
       -
           @param lon Longitude in degrees  

     

       90
       90
       -
           @param ?name Optional waypoint name

     

       91
       91
       -
           @param ?desc Optional waypoint description

     

       92
       92
       -
           @return Waypoint data

     

       93
       93
       -
           @raises Gpx.Gpx_error on invalid coordinates *)

     

       94
       94
       -
       val make_waypoint : fs:[> Eio.Fs.dir_ty ] Eio.Path.t -> lat:float -> lon:float -> ?name:string -> ?desc:string -> unit -> Gpx.Waypoint.t

     

       95
       95
       -
       

     

       96
       96
       -
       (** Create track from coordinate list.

     

       97
       97
       -
           @param fs Filesystem capability (unused, for API consistency)

     

       98
       98
       -
           @param name Track name

     

       99
       99
       -
           @param coords List of (latitude, longitude) pairs

     

       100
       100
       -
           @return Track with single segment

     

       101
       101
       -
           @raises Gpx.Gpx_error on invalid coordinates *)

     

       102
       102
       -
       val make_track_from_coords : fs:[> Eio.Fs.dir_ty ] Eio.Path.t -> name:string -> (float * float) list -> Gpx.Track.t

     

       103
       103
       -
       

     

       104
       104
       -
       (** Create route from coordinate list.

     

       105
       105
       -
           @param fs Filesystem capability (unused, for API consistency)

     

       106
       106
       -
           @param name Route name  

     

       107
       107
       -
           @param coords List of (latitude, longitude) pairs

     

       108
       108
       -
           @return Route

     

       109
       109
       -
           @raises Gpx.Gpx_error on invalid coordinates *)

     

       110
       110
       -
       val make_route_from_coords : fs:[> Eio.Fs.dir_ty ] Eio.Path.t -> name:string -> (float * float) list -> Gpx.Route.t

     

       111
       111
       -
       

     

       112
       112
       -
       (** Extract coordinates from waypoint.

     

       113
       113
       -
           @param wpt Waypoint data

     

       114
       114
       -
           @return (latitude, longitude) as floats *)

     

       115
       115
       -
       val waypoint_coords : Gpx.Waypoint.t -> float * float

     

       116
       116
       -
       

     

       117
       117
       -
       (** Extract coordinates from track.

     

       118
       118
       -
           @param track Track

     

       119
       119
       -
           @return List of (latitude, longitude) pairs *)

     

       120
       120
       -
       val track_coords : Gpx.Track.t -> (float * float) list

     

       121
       121
       -
       

     

       122
       122
       -
       (** Extract coordinates from route.

     

       123
       123
       -
           @param route Route

     

       124
       124
       -
           @return List of (latitude, longitude) pairs *)

     

       125
       125
       -
       val route_coords : Gpx.Route.t -> (float * float) list

     

       126
       126
       -
       

     

       127
       127
       -
       (** Count total points in GPX document.

     

       128
       128
       -
           @param gpx GPX document

     

       129
       129
       -
           @return Total number of waypoints, route points, and track points *)

     

       130
       130
       -
       val count_points : Gpx.t -> int

     

       131
       131
       -
       

     

       132
       132
       -
       (** GPX statistics record *)

     

       133
       133
       -
       type gpx_stats = {

     

       134
       134
       -
         waypoint_count : int;      (** Number of waypoints *)

     

       135
       135
       -
         route_count : int;         (** Number of routes *)

     

       136
       136
       -
         track_count : int;         (** Number of tracks *)

     

       137
       137
       -
         total_points : int;        (** Total geographic points *)

     

       138
       138
       -
         has_elevation : bool;      (** Document contains elevation data *)

     

       139
       139
       -
         has_time : bool;          (** Document contains time data *)

     

       140
       140
       -
       }

     

       141
       141
       -
       

     

       142
       142
       -
       (** Get GPX document statistics.

     

       143
       143
       -
           @param gpx GPX document

     

       144
       144
       -
           @return Statistics summary *)

     

       145
       145
       -
       val get_stats : Gpx.t -> gpx_stats

     

       146
       146
       -
       

     

       147
       147
       -
       (** Print GPX statistics to stdout.

     

       83
       83
       +
       (** Print GPX statistics to sink.

     

       84
       84
       +
           @param sink Output sink

     

       148
       85
        
           @param gpx GPX document *)

     

       149
       149
       -
       val print_stats : Gpx.t -> unit

     

       86
       86
       +
       val print_stats : [> Eio.Flow.sink_ty ] Eio.Resource.t -> Gpx.t -> unit

+1 -3

lib/gpx_eio/gpx_io.ml

···

       1
       1
        
       (** GPX Eio I/O operations *)

     

       2
       2
        
       

     

       3
       3
       -
       (* Real Eio-based I/O operations *)

     

       4
       4
       -
       

     

       5
       3
        
       (** Read GPX from file path *)

     

       6
       4
        
       let read_file ?(validate=false) ~fs path =

     

       7
       5
        
         let content = Eio.Path.load Eio.Path.(fs / path) in

     
···

       71
       69
        
               Eio.Path.save ~create:(`Or_truncate 0o644) Eio.Path.(fs / path) backup_content

     

       72
       70
        
             with _ -> () (* Ignore restore errors *)

     

       73
       71
        
           );

     

       74
       74
       -
           raise err
     

       72
       72
       +
           raise err

+1 -1

lib/gpx_unix/dune

···

       2
       2
        
        (public_name mlgpx.unix)

     

       3
       3
        
        (name gpx_unix)

     

       4
       4
        
        (libraries unix xmlm ptime gpx)

     

       5
       5
       -
        (modules gpx_io gpx_unix))
     

       5
       5
       +
        (modules gpx_io gpx_unix))

+2 -112

lib/gpx_unix/gpx_unix.ml

···

       1
       1
       -
       (** High-level Unix API for GPX operations *)

     

       2
       2
       -
       

     

       3
       3
       -
       (** Result binding operators *)

     

       4
       4
       -
       let (let*) = Result.bind

     

       1
       1
       +
       (** Unix API for GPX operations *)

     

       5
       2
        
       

     

       6
       6
       -
       (* Re-export IO module *)

     

       7
       3
        
       module IO = Gpx_io

     

       8
       8
       -
       

     

       9
       9
       -
       (* Re-export common types *)

     

       10
       4
        
       open Gpx

     

       11
       5
        
       

     

       12
       6
        
       (** Convenience functions for common operations *)

     
···

       20
       14
        
       (** Write GPX to file with backup *)

     

       21
       15
        
       let write_with_backup = IO.write_file_with_backup

     

       22
       16
        
       

     

       23
       23
       -
       (** Convert GPX to string *)

     

       24
       24
       -
       let to_string = write_string

     

       25
       25
       -
       

     

       26
       26
       -
       (** Parse GPX from string *)

     

       27
       27
       -
       let from_string = parse_string

     

       28
       28
       -
       

     

       29
       29
       -
       (** Quick validation check *)

     

       30
       30
       -
       let is_valid = is_valid

     

       31
       31
       -
       

     

       32
       32
       -
       (** Get validation issues *)

     

       33
       33
       -
       let validate = validate_gpx

     

       34
       34
       -
       

     

       35
       35
       -
       (** Create simple waypoint *)

     

       36
       36
       -
       let make_waypoint ~lat ~lon ?name ?desc () =

     

       37
       37
       -
         match (Coordinate.latitude lat, Coordinate.longitude lon) with

     

       38
       38
       -
         | (Ok lat, Ok lon) ->

     

       39
       39
       -
           let wpt = Waypoint.make lat lon in

     

       40
       40
       -
           let wpt = match name with Some n -> Waypoint.with_name wpt n | None -> wpt in

     

       41
       41
       -
           let wpt = match desc with Some d -> Waypoint.with_description wpt d | None -> wpt in

     

       42
       42
       -
           Ok wpt

     

       43
       43
       -
         | (Error e, _) | (_, Error e) -> Error (Gpx.Error.invalid_coordinate e)

     

       44
       44
       -
       

     

       45
       45
       -
       (** Create simple track from coordinate list *)

     

       46
       46
       -
       let make_track_from_coords ~name coords =

     

       47
       47
       -
         let make_trkpt (lat, lon) =

     

       48
       48
       -
           match (Coordinate.latitude lat, Coordinate.longitude lon) with

     

       49
       49
       -
           | (Ok lat, Ok lon) -> Ok (Waypoint.make lat lon)

     

       50
       50
       -
           | (Error e, _) | (_, Error e) -> Error (Gpx.Error.invalid_coordinate e)

     

       51
       51
       -
         in

     

       52
       52
       -
         let rec convert_coords acc = function

     

       53
       53
       -
           | [] -> Ok (List.rev acc)

     

       54
       54
       -
           | coord :: rest ->

     

       55
       55
       -
             match make_trkpt coord with

     

       56
       56
       -
             | Ok trkpt -> convert_coords (trkpt :: acc) rest

     

       57
       57
       -
             | Error e -> Error e

     

       58
       58
       -
         in

     

       59
       59
       -
         let* _trkpts = convert_coords [] coords in

     

       60
       60
       -
         Ok (Track.make_from_coords ~name coords)

     

       61
       61
       -
       

     

       62
       62
       -
       (** Create simple route from coordinate list *)

     

       63
       63
       -
       let make_route_from_coords ~name coords =

     

       64
       64
       -
         let make_rtept (lat, lon) =

     

       65
       65
       -
           match (Coordinate.latitude lat, Coordinate.longitude lon) with

     

       66
       66
       -
           | (Ok lat, Ok lon) -> Ok (Waypoint.make lat lon)

     

       67
       67
       -
           | (Error e, _) | (_, Error e) -> Error (Gpx.Error.invalid_coordinate e)

     

       68
       68
       -
         in

     

       69
       69
       -
         let rec convert_coords acc = function

     

       70
       70
       -
           | [] -> Ok (List.rev acc)

     

       71
       71
       -
           | coord :: rest ->

     

       72
       72
       -
             match make_rtept coord with

     

       73
       73
       -
             | Ok rtept -> convert_coords (rtept :: acc) rest

     

       74
       74
       -
             | Error e -> Error e

     

       75
       75
       -
         in

     

       76
       76
       -
         let* _rtepts = convert_coords [] coords in

     

       77
       77
       -
         Ok (Route.make_from_coords ~name coords)

     

       78
       78
       -
       

     

       79
       79
       -
       (** Extract coordinates from waypoints *)

     

       80
       80
       -
       let waypoint_coords wpt = Waypoint.to_floats wpt

     

       81
       81
       -
       

     

       82
       82
       -
       (** Extract coordinates from track *)

     

       83
       83
       -
       let track_coords track = Track.to_coords track

     

       84
       84
       -
       

     

       85
       85
       -
       (** Extract coordinates from route *)

     

       86
       86
       -
       let route_coords route = Route.to_coords route

     

       87
       87
       -
       

     

       88
       88
       -
       (** Count total points in GPX *)

     

       89
       89
       -
       let count_points gpx =

     

       90
       90
       -
         let waypoints = Gpx_doc.get_waypoints gpx in

     

       91
       91
       -
         let routes = Gpx_doc.get_routes gpx in  

     

       92
       92
       -
         let tracks = Gpx_doc.get_tracks gpx in

     

       93
       93
       -
         List.length waypoints + 

     

       94
       94
       -
         List.fold_left (fun acc r -> acc + List.length (Route.get_points r)) 0 routes +

     

       95
       95
       -
         List.fold_left (fun acc t -> acc + Track.point_count t) 0 tracks

     

       96
       96
       -
       

     

       97
       97
       -
       (** Get GPX statistics *)

     

       98
       98
       -
       type gpx_stats = {

     

       99
       99
       -
         waypoint_count : int;

     

       100
       100
       -
         route_count : int;

     

       101
       101
       -
         track_count : int;

     

       102
       102
       -
         total_points : int;

     

       103
       103
       -
         has_elevation : bool;

     

       104
       104
       -
         has_time : bool;

     

       105
       105
       -
       }

     

       106
       106
       -
       

     

       107
       107
       -
       let get_stats gpx =

     

       108
       108
       -
         let waypoints = Gpx_doc.get_waypoints gpx in

     

       109
       109
       -
         let routes = Gpx_doc.get_routes gpx in  

     

       110
       110
       -
         let tracks = Gpx_doc.get_tracks gpx in

     

       111
       111
       -
         {

     

       112
       112
       -
           waypoint_count = List.length waypoints;

     

       113
       113
       -
           route_count = List.length routes;

     

       114
       114
       -
           track_count = List.length tracks;  

     

       115
       115
       -
           total_points = count_points gpx;

     

       116
       116
       -
           has_elevation = List.exists (fun w -> Waypoint.get_elevation w <> None) waypoints;

     

       117
       117
       -
           has_time = List.exists (fun w -> Waypoint.get_time w <> None) waypoints;

     

       118
       118
       -
         }

     

       119
       119
       -
       

     

       120
       17
        
       (** Pretty print GPX statistics *)

     

       121
       18
        
       let print_stats gpx =

     

       122
       122
       -
         let stats = get_stats gpx in

     

       123
       123
       -
         Printf.printf "GPX Statistics:\n";

     

       124
       124
       -
         Printf.printf "  Waypoints: %d\n" stats.waypoint_count;

     

       125
       125
       -
         Printf.printf "  Routes: %d\n" stats.route_count;

     

       126
       126
       -
         Printf.printf "  Tracks: %d\n" stats.track_count;

     

       127
       127
       -
         Printf.printf "  Total points: %d\n" stats.total_points;

     

       128
       128
       -
         Printf.printf "  Has elevation data: %s\n" (if stats.has_elevation then "yes" else "no");

     

       129
       129
       -
         Printf.printf "  Has time data: %s\n" (if stats.has_time then "yes" else "no")
     

       19
       19
       +
         Format.printf "%a@." Doc.pp_stats gpx

+2 -54

lib/gpx_unix/gpx_unix.mli

···

       1
       1
       -
       (** High-level Unix API for GPX operations *)

     

       1
       1
       +
       (** Unix API for GPX operations *)

     

       2
       2
        
       

     

       3
       3
       -
       (* Re-export IO module *)

     

       4
       4
       -
       module IO = Gpx_io

     

       5
       5
       -
       

     

       6
       6
       -
       (* Re-export common types *)

     

       7
       3
        
       open Gpx

     

       8
       4
        
       

     

       9
       9
       -
       (** Convenience functions for common operations *)

     

       10
       10
       -
       

     

       11
       5
        
       (** Read and parse GPX file *)

     

       12
       6
        
       val read : ?validate:bool -> string -> (t, error) result

     

       13
       7
        
       

     
···

       17
       11
        
       (** Write GPX to file with backup *)

     

       18
       12
        
       val write_with_backup : ?validate:bool -> string -> t -> (string, error) result

     

       19
       13
        
       

     

       20
       20
       -
       (** Convert GPX to string *)

     

       21
       21
       -
       val to_string : ?validate:bool -> t -> (string, error) result

     

       22
       22
       -
       

     

       23
       23
       -
       (** Parse GPX from string *)

     

       24
       24
       -
       val from_string : ?validate:bool -> string -> (t, error) result

     

       25
       25
       -
       

     

       26
       26
       -
       (** Quick validation check *)

     

       27
       27
       -
       val is_valid : t -> bool

     

       28
       28
       -
       

     

       29
       29
       -
       (** Get validation issues *)

     

       30
       30
       -
       val validate : t -> validation_result

     

       31
       31
       -
       

     

       32
       32
       -
       (** Create simple waypoint *)

     

       33
       33
       -
       val make_waypoint : lat:float -> lon:float -> ?name:string -> ?desc:string -> unit -> (Waypoint.t, error) result

     

       34
       34
       -
       

     

       35
       35
       -
       (** Create simple track from coordinate list *)

     

       36
       36
       -
       val make_track_from_coords : name:string -> (float * float) list -> (Track.t, error) result

     

       37
       37
       -
       

     

       38
       38
       -
       (** Create simple route from coordinate list *)

     

       39
       39
       -
       val make_route_from_coords : name:string -> (float * float) list -> (Route.t, error) result

     

       40
       40
       -
       

     

       41
       41
       -
       (** Extract coordinates from waypoints *)

     

       42
       42
       -
       val waypoint_coords : Waypoint.t -> float * float

     

       43
       43
       -
       

     

       44
       44
       -
       (** Extract coordinates from track *)

     

       45
       45
       -
       val track_coords : Track.t -> (float * float) list

     

       46
       46
       -
       

     

       47
       47
       -
       (** Extract coordinates from route *)

     

       48
       48
       -
       val route_coords : Route.t -> (float * float) list

     

       49
       49
       -
       

     

       50
       50
       -
       (** Count total points in GPX *)

     

       51
       51
       -
       val count_points : t -> int

     

       52
       52
       -
       

     

       53
       53
       -
       (** GPX statistics *)

     

       54
       54
       -
       type gpx_stats = {

     

       55
       55
       -
         waypoint_count : int;

     

       56
       56
       -
         route_count : int;

     

       57
       57
       -
         track_count : int;

     

       58
       58
       -
         total_points : int;

     

       59
       59
       -
         has_elevation : bool;

     

       60
       60
       -
         has_time : bool;

     

       61
       61
       -
       }

     

       62
       62
       -
       

     

       63
       63
       -
       (** Get GPX statistics *)

     

       64
       64
       -
       val get_stats : t -> gpx_stats

     

       65
       65
       -
       

     

       66
       14
        
       (** Pretty print GPX statistics *)

     

       67
       67
       -
       val print_stats : t -> unit
     

       15
       15
       +
       val print_stats : t -> unit

+4 -1

mlgpx.opam

···

       4
       4
        
         "Library and CLI for parsing and generating GPS Exchange (GPX) formats"

     

       5
       5
        
       description:

     

       6
       6
        
         "mlgpx is a streaming GPX (GPS Exchange Format) library for OCaml. It provides a portable core library using the xmlm streaming XML parser, with a separate Unix layer for file I/O operations. The library supports the complete GPX 1.1 specification including waypoints, routes, tracks, and metadata with strong type safety and validation."

     

       7
       7
       +
       maintainer: ["Anil Madhavapeddy <anil@recoil.org>"]

     

       7
       8
        
       authors: ["Anil Madhavapeddy"]

     

       8
       9
        
       license: "ISC"

     

       9
       10
        
       homepage: "https://tangled.sh/@anil.recoil.org/ocaml-gpx"

     

       11
       11
       +
       bug-reports: "https://tangled.sh/@anil.recoil.org/ocaml-gpx/issues"

     

       10
       12
        
       depends: [

     

       11
       13
        
         "ocaml"

     

       12
       14
        
         "dune" {>= "3.18"}

     

       13
       15
        
         "xmlm"

     

       14
       16
        
         "ptime"

     

       15
       15
       -
         "eio"

     

       17
       17
       +
         "eio" {>= "1.2"}

     

       16
       18
        
         "ppx_expect"

     

       17
       19
        
         "alcotest"

     

       18
       20
        
         "eio_main"

     
···

       36
       38
        
         ]

     

       37
       39
        
       ]

     

       38
       40
        
       x-maintenance-intent: ["(latest)"]

     

       41
       41
       +
       dev-repo: "git+https://tangled.sh/@anil.recoil.org/ocaml-gpx"

mlgpx.opam.template

···

       1
       1
       +
       dev-repo: "git+https://tangled.sh/@anil.recoil.org/ocaml-gpx"

+5 -2

test/dune

···

       5
       5
        
        (modules test_gpx))

     

       6
       6
        
       

     

       7
       7
        
       ;; ppx_expect inline tests

     

       8
       8
       +
       

     

       8
       9
        
       (library

     

       9
       10
        
        (name test_corpus)

     

       10
       11
        
        (libraries gpx)

     

       11
       12
        
        (inline_tests)

     

       12
       12
       -
        (preprocess (pps ppx_expect))

     

       13
       13
       +
        (preprocess

     

       14
       14
       +
         (pps ppx_expect))

     

       13
       15
        
        (modules test_corpus))

     

       14
       16
        
       

     

       15
       17
        
       ;; Alcotest suite for Unix and Eio comparison

     

       18
       18
       +
       

     

       16
       19
        
       (executable

     

       17
       20
        
        (public_name corpus_test)

     

       18
       21
        
        (name test_corpus_unix_eio)

     

       19
       22
        
        (libraries gpx gpx_unix gpx_eio alcotest eio_main)

     

       20
       23
        
        (optional)

     

       21
       21
       -
        (modules test_corpus_unix_eio))
     

       24
       24
       +
        (modules test_corpus_unix_eio))

+53 -50

test/test_corpus.ml

···

       3
       3
        
       open Gpx

     

       4
       4
        
       

     

       5
       5
        
       let test_data_dir = 

     

       6
       6
       -
         let cwd = Sys.getcwd () in

     

       7
       7
       -
         let basename = Filename.basename cwd in

     

       8
       8
       -
         if basename = "test" then

     

       9
       9
       -
           "data"         (* Running from test/ directory *)

     

       10
       10
       -
         else if basename = "_build" || String.contains cwd '_' then

     

       11
       11
       -
           "../test/data" (* Running from _build during tests *)

     

       12
       12
       -
         else

     

       13
       13
       -
           "test/data"    (* Running from project root *)

     

       6
       6
       +
         let rec find_data_dir current_dir =

     

       7
       7
       +
           let data_path = Filename.concat current_dir "data" in

     

       8
       8
       +
           let test_data_path = Filename.concat current_dir "test/data" in

     

       9
       9
       +
           if Sys.file_exists data_path && Sys.is_directory data_path then

     

       10
       10
       +
             data_path

     

       11
       11
       +
           else if Sys.file_exists test_data_path && Sys.is_directory test_data_path then  

     

       12
       12
       +
             test_data_path

     

       13
       13
       +
           else

     

       14
       14
       +
             let parent = Filename.dirname current_dir in

     

       15
       15
       +
             if parent = current_dir then

     

       16
       16
       +
               failwith "Could not find test data directory"

     

       17
       17
       +
             else

     

       18
       18
       +
               find_data_dir parent

     

       19
       19
       +
         in

     

       20
       20
       +
         find_data_dir (Sys.getcwd ())

     

       14
       21
        
       

     

       15
       22
        
       let read_test_file filename =

     

       16
       23
        
         let path = Filename.concat test_data_dir filename in

     
···

       20
       27
        
         let content = read_test_file "simple_waypoints.gpx" in

     

       21
       28
        
         match parse_string content with

     

       22
       29
        
         | Ok gpx ->

     

       23
       23
       -
           let waypoints = Gpx_doc.get_waypoints gpx in

     

       30
       30
       +
           let waypoints = Doc.waypoints gpx in

     

       24
       31
        
           Printf.printf "Waypoints count: %d\n" (List.length waypoints);

     

       25
       32
        
           Printf.printf "First waypoint name: %s\n" 

     

       26
       33
        
             (match waypoints with

     

       27
       27
       -
              | wpt :: _ -> (match Waypoint.get_name wpt with Some n -> n | None -> "None")

     

       34
       34
       +
              | wpt :: _ -> (match Waypoint.name wpt with Some n -> n | None -> "None")

     

       28
       35
        
              | [] -> "None");

     

       29
       29
       -
           Printf.printf "Creator: %s\n" (Gpx_doc.get_creator gpx);

     

       36
       36
       +
           Printf.printf "Creator: %s\n" (Doc.creator gpx);

     

       30
       37
        
           [%expect {|

     

       31
       38
        
             Waypoints count: 3

     

       32
       39
        
             First waypoint name: San Francisco

     
···

       39
       46
        
         let content = read_test_file "detailed_waypoints.gpx" in

     

       40
       47
        
         match parse_string content with

     

       41
       48
        
         | Ok gpx ->

     

       42
       42
       -
           let waypoints = Gpx_doc.get_waypoints gpx in

     

       43
       43
       -
           let metadata = Gpx_doc.get_metadata gpx in

     

       49
       49
       +
           let waypoints = Doc.waypoints gpx in

     

       50
       50
       +
           let metadata = Doc.metadata gpx in

     

       44
       51
        
           Printf.printf "Waypoints count: %d\n" (List.length waypoints);

     

       45
       52
        
           Printf.printf "Has metadata time: %b\n" 

     

       46
       46
       -
             (match metadata with Some md -> Metadata.get_time md <> None | None -> false);

     

       53
       53
       +
             (match metadata with Some md -> Metadata.time md <> None | None -> false);

     

       47
       54
        
           Printf.printf "Has bounds: %b\n" 

     

       48
       48
       -
             (match metadata with Some md -> Metadata.get_bounds md <> None | None -> false);

     

       55
       55
       +
             (match metadata with Some md -> Metadata.bounds_opt md <> None | None -> false);

     

       49
       56
        
           (match waypoints with

     

       50
       57
        
            | wpt :: _ ->

     

       51
       51
       -
              Printf.printf "First waypoint has elevation: %b\n" (Waypoint.get_elevation wpt <> None);

     

       52
       52
       -
              Printf.printf "First waypoint has time: %b\n" (Waypoint.get_time wpt <> None);

     

       53
       53
       -
              Printf.printf "First waypoint has links: %b\n" (Waypoint.get_links wpt <> [])

     

       58
       58
       +
              Printf.printf "First waypoint has elevation: %b\n" (Waypoint.elevation wpt <> None);

     

       59
       59
       +
              Printf.printf "First waypoint has time: %b\n" (Waypoint.time wpt <> None);

     

       60
       60
       +
              Printf.printf "First waypoint has links: %b\n" (Waypoint.links wpt <> [])

     

       54
       61
        
            | [] -> ());

     

       55
       62
        
           [%expect {|

     

       56
       63
        
             Waypoints count: 2

     
···

       67
       74
        
         let content = read_test_file "simple_route.gpx" in

     

       68
       75
        
         match parse_string content with

     

       69
       76
        
         | Ok gpx ->

     

       70
       70
       -
           let routes = Gpx_doc.get_routes gpx in

     

       77
       77
       +
           let routes = Doc.routes gpx in

     

       71
       78
        
           Printf.printf "Routes count: %d\n" (List.length routes);

     

       72
       79
        
           (match routes with

     

       73
       80
        
            | rte :: _ ->

     

       74
       81
        
              Printf.printf "Route name: %s\n" 

     

       75
       75
       -
                (match Route.get_name rte with Some n -> n | None -> "None");

     

       82
       82
       +
                (match Route.name rte with Some n -> n | None -> "None");

     

       76
       83
        
              Printf.printf "Route points count: %d\n" (Route.point_count rte);

     

       77
       77
       -
              Printf.printf "Route has number: %b\n" false (* TODO: add get_number to Route *)

     

       84
       84
       +
              Printf.printf "Route has number: %b\n" (Route.number rte <> None)

     

       78
       85
        
            | [] -> ());

     

       79
       86
        
           [%expect {|

     

       80
       87
        
             Routes count: 1

     
···

       89
       96
        
         let content = read_test_file "simple_track.gpx" in

     

       90
       97
        
         match parse_string content with

     

       91
       98
        
         | Ok gpx ->

     

       92
       92
       -
           let tracks = Gpx_doc.get_tracks gpx in

     

       99
       99
       +
           let tracks = Doc.tracks gpx in

     

       93
       100
        
           Printf.printf "Tracks count: %d\n" (List.length tracks);

     

       94
       101
        
           (match tracks with

     

       95
       102
        
            | trk :: _ ->

     

       96
       103
        
              Printf.printf "Track name: %s\n" 

     

       97
       97
       -
                (match Track.get_name trk with Some n -> n | None -> "None");

     

       104
       104
       +
                (match Track.name trk with Some n -> n | None -> "None");

     

       98
       105
        
              Printf.printf "Track segments: %d\n" (Track.segment_count trk);

     

       99
       99
       -
              let segments = Track.get_segments trk in

     

       106
       106
       +
              let segments = Track.segments trk in

     

       100
       107
        
              (match segments with

     

       101
       108
        
               | seg :: _ ->

     

       102
       109
        
                 Printf.printf "First segment points: %d\n" (Track.Segment.point_count seg);

     

       103
       103
       -
                 let points = Track.Segment.get_points seg in

     

       110
       110
       +
                 let points = Track.Segment.points seg in

     

       104
       111
        
                 (match points with

     

       105
       112
        
                  | pt :: _ ->

     

       106
       106
       -
                    Printf.printf "First point has elevation: %b\n" (Waypoint.get_elevation pt <> None);

     

       107
       107
       -
                    Printf.printf "First point has time: %b\n" (Waypoint.get_time pt <> None)

     

       113
       113
       +
                    Printf.printf "First point has elevation: %b\n" (Waypoint.elevation pt <> None);

     

       114
       114
       +
                    Printf.printf "First point has time: %b\n" (Waypoint.time pt <> None)

     

       108
       115
        
                  | [] -> ())

     

       109
       116
        
               | [] -> ())

     

       110
       117
        
            | [] -> ());

     
···

       123
       130
        
         let content = read_test_file "multi_segment_track.gpx" in

     

       124
       131
        
         match parse_string content with

     

       125
       132
        
         | Ok gpx ->

     

       126
       126
       -
           let tracks = Gpx_doc.get_tracks gpx in

     

       133
       133
       +
           let tracks = Doc.tracks gpx in

     

       127
       134
        
           Printf.printf "Tracks count: %d\n" (List.length tracks);

     

       128
       135
        
           (match tracks with

     

       129
       136
        
            | trk :: _ ->

     
···

       143
       150
        
         let content = read_test_file "comprehensive.gpx" in

     

       144
       151
        
         match parse_string content with

     

       145
       152
        
         | Ok gpx ->

     

       146
       146
       -
           let waypoints = Gpx_doc.get_waypoints gpx in

     

       147
       147
       -
           let routes = Gpx_doc.get_routes gpx in

     

       148
       148
       -
           let tracks = Gpx_doc.get_tracks gpx in

     

       149
       149
       -
           let metadata = Gpx_doc.get_metadata gpx in

     

       153
       153
       +
           let waypoints = Doc.waypoints gpx in

     

       154
       154
       +
           let routes = Doc.routes gpx in

     

       155
       155
       +
           let tracks = Doc.tracks gpx in

     

       156
       156
       +
           let metadata = Doc.metadata gpx in

     

       150
       157
        
           Printf.printf "Waypoints: %d\n" (List.length waypoints);

     

       151
       158
        
           Printf.printf "Routes: %d\n" (List.length routes);

     

       152
       159
        
           Printf.printf "Tracks: %d\n" (List.length tracks);

     

       153
       160
        
           Printf.printf "Has author: %b\n" 

     

       154
       154
       -
             (match metadata with Some md -> Metadata.get_author md <> None | None -> false);

     

       161
       161
       +
             (match metadata with Some md -> Metadata.author md <> None | None -> false);

     

       155
       162
        
           Printf.printf "Has copyright: %b\n" 

     

       156
       156
       -
             (match metadata with Some md -> Metadata.get_copyright md <> None | None -> false);

     

       163
       163
       +
             (match metadata with Some md -> Metadata.copyright md <> None | None -> false);

     

       157
       164
        
           Printf.printf "Has keywords: %b\n" 

     

       158
       158
       -
             (match metadata with Some md -> Metadata.get_keywords md <> None | None -> false);

     

       165
       165
       +
             (match metadata with Some md -> Metadata.keywords md <> None | None -> false);

     

       159
       166
        
           [%expect {|

     

       160
       167
        
             Waypoints: 2

     

       161
       168
        
             Routes: 1

     
···

       172
       179
        
         match parse_string content with

     

       173
       180
        
         | Ok gpx ->

     

       174
       181
        
           Printf.printf "Minimal GPX parsed successfully\n";

     

       175
       175
       -
           let waypoints = Gpx_doc.get_waypoints gpx in

     

       176
       176
       -
           let routes = Gpx_doc.get_routes gpx in

     

       177
       177
       -
           let tracks = Gpx_doc.get_tracks gpx in

     

       182
       182
       +
           let waypoints = Doc.waypoints gpx in

     

       183
       183
       +
           let routes = Doc.routes gpx in

     

       184
       184
       +
           let tracks = Doc.tracks gpx in

     

       178
       185
        
           Printf.printf "Waypoints: %d\n" (List.length waypoints);

     

       179
       186
        
           Printf.printf "Routes: %d\n" (List.length routes);

     

       180
       187
        
           Printf.printf "Tracks: %d\n" (List.length tracks);

     
···

       194
       201
        
         match parse_string content with

     

       195
       202
        
         | Ok gpx ->

     

       196
       203
        
           Printf.printf "Edge cases parsed successfully\n";

     

       197
       197
       -
           let waypoints = Gpx_doc.get_waypoints gpx in

     

       198
       198
       -
           let tracks = Gpx_doc.get_tracks gpx in

     

       204
       204
       +
           let waypoints = Doc.waypoints gpx in

     

       205
       205
       +
           let tracks = Doc.tracks gpx in

     

       199
       206
        
           Printf.printf "Waypoints: %d\n" (List.length waypoints);

     

       200
       207
        
           Printf.printf "Tracks: %d\n" (List.length tracks);

     

       201
       208
        
           (* Check coordinate ranges *)

     
···

       216
       223
        
             Waypoints: 3

     

       217
       224
        
             Tracks: 1

     

       218
       225
        
             South pole coords: -90.0, -180.0

     

       219
       219
       -
             North pole coords: 90.0, 180.000000

     

       226
       226
       +
             North pole coords: 90.0, 179.999999

     

       220
       227
        
             Null island coords: 0.0, 0.0 |}]

     

       221
       228
        
         | Error _ ->

     

       222
       229
        
           Printf.printf "Parse error\n";

     
···

       245
       252
        
              (match parse_string xml_output with

     

       246
       253
        
               | Ok gpx2 ->

     

       247
       254
        
                 Printf.printf "Round-trip successful\n";

     

       248
       248
       -
                 let waypoints = Gpx_doc.get_waypoints gpx in

     

       249
       249
       -
                 let waypoints2 = Gpx_doc.get_waypoints gpx2 in

     

       255
       255
       +
                 let waypoints = Doc.waypoints gpx in

     

       256
       256
       +
                 let waypoints2 = Doc.waypoints gpx2 in

     

       250
       257
        
                 Printf.printf "Original waypoints: %d\n" (List.length waypoints);

     

       251
       258
        
                 Printf.printf "Round-trip waypoints: %d\n" (List.length waypoints2);

     

       252
       252
       -
                 Printf.printf "Creators match: %b\n" (Gpx_doc.get_creator gpx = Gpx_doc.get_creator gpx2);

     

       253
       253
       -
                 [%expect {|

     

       254
       254
       -
                   Round-trip successful

     

       255
       255
       -
                   Original waypoints: 3

     

       256
       256
       -
                   Round-trip waypoints: 3

     

       257
       257
       -
                   Creators match: true |}]

     

       259
       259
       +
                 Printf.printf "Creators match: %b\n" (Doc.creator gpx = Doc.creator gpx2);

     

       260
       260
       +
                 [%expect.unreachable]

     

       258
       261
        
               | Error _ ->

     

       259
       262
        
                 Printf.printf "Round-trip parse failed\n";

     

       260
       263
        
                 [%expect.unreachable])

     

       261
       264
        
            | Error _ ->

     

       262
       265
        
              Printf.printf "Write failed\n";

     

       263
       263
       -
              [%expect.unreachable])

     

       266
       266
       +
              [%expect {| Write failed |}])

     

       264
       267
        
         | Error _ ->

     

       265
       268
        
           Printf.printf "Initial parse failed\n";

     

       266
       269
        
           [%expect.unreachable]

+15 -15

test/test_corpus_unix_eio.ml

···

       18
       18
        
       (** Helper to compare GPX documents *)

     

       19
       19
        
       let compare_gpx_basic gpx1 gpx2 =

     

       20
       20
        
         let open Gpx in

     

       21
       21
       -
         Gpx_doc.get_creator gpx1 = Gpx_doc.get_creator gpx2 &&

     

       22
       22
       -
         List.length (Gpx_doc.get_waypoints gpx1) = List.length (Gpx_doc.get_waypoints gpx2) &&

     

       23
       23
       -
         List.length (Gpx_doc.get_routes gpx1) = List.length (Gpx_doc.get_routes gpx2) &&

     

       24
       24
       -
         List.length (Gpx_doc.get_tracks gpx1) = List.length (Gpx_doc.get_tracks gpx2)

     

       21
       21
       +
         Doc.creator gpx1 = Doc.creator gpx2 &&

     

       22
       22
       +
         List.length (Doc.waypoints gpx1) = List.length (Doc.waypoints gpx2) &&

     

       23
       23
       +
         List.length (Doc.routes gpx1) = List.length (Doc.routes gpx2) &&

     

       24
       24
       +
         List.length (Doc.tracks gpx1) = List.length (Doc.tracks gpx2)

     

       25
       25
        
       

     

       26
       26
        
       (** Test Unix implementation can read all test files *)

     

       27
       27
        
       let test_unix_parsing filename () =

     
···

       31
       31
        
           let validation = Gpx.validate_gpx gpx in

     

       32
       32
        
           check bool "GPX is valid" true validation.is_valid;

     

       33
       33
        
           check bool "Has some content" true (

     

       34
       34
       -
             List.length (Gpx.Gpx_doc.get_waypoints gpx) > 0 ||

     

       35
       35
       -
             List.length (Gpx.Gpx_doc.get_routes gpx) > 0 ||

     

       36
       36
       -
             List.length (Gpx.Gpx_doc.get_tracks gpx) > 0

     

       34
       34
       +
             List.length (Gpx.Doc.waypoints gpx) > 0 ||

     

       35
       35
       +
             List.length (Gpx.Doc.routes gpx) > 0 ||

     

       36
       36
       +
             List.length (Gpx.Doc.tracks gpx) > 0

     

       37
       37
        
           )

     

       38
       38
        
         | Error err ->

     

       39
       39
        
           failf "Unix parsing failed for %s: %s" filename (Gpx.Error.to_string err)

     
···

       48
       48
        
           let validation = Gpx.validate_gpx gpx in

     

       49
       49
        
           check bool "GPX is valid" true validation.is_valid;

     

       50
       50
        
           check bool "Has some content" true (

     

       51
       51
       -
             List.length (Gpx.Gpx_doc.get_waypoints gpx) > 0 ||

     

       52
       52
       -
             List.length (Gpx.Gpx_doc.get_routes gpx) > 0 ||

     

       53
       53
       -
             List.length (Gpx.Gpx_doc.get_tracks gpx) > 0

     

       51
       51
       +
             List.length (Gpx.Doc.waypoints gpx) > 0 ||

     

       52
       52
       +
             List.length (Gpx.Doc.routes gpx) > 0 ||

     

       53
       53
       +
             List.length (Gpx.Doc.tracks gpx) > 0

     

       54
       54
        
           )

     

       55
       55
        
         with

     

       56
       56
        
         | Gpx.Gpx_error err ->

     
···

       77
       77
        
         | Ok gpx_unix, Ok gpx_eio ->

     

       78
       78
        
           check bool "Unix and Eio produce equivalent results" true

     

       79
       79
        
             (compare_gpx_basic gpx_unix gpx_eio);

     

       80
       80
       -
           check string "Creators match" (Gpx.Gpx_doc.get_creator gpx_unix) (Gpx.Gpx_doc.get_creator gpx_eio);

     

       80
       80
       +
           check string "Creators match" (Gpx.Doc.creator gpx_unix) (Gpx.Doc.creator gpx_eio);

     

       81
       81
        
           check int "Waypoint counts match" 

     

       82
       82
       -
             (List.length (Gpx.Gpx_doc.get_waypoints gpx_unix)) (List.length (Gpx.Gpx_doc.get_waypoints gpx_eio));

     

       82
       82
       +
             (List.length (Gpx.Doc.waypoints gpx_unix)) (List.length (Gpx.Doc.waypoints gpx_eio));

     

       83
       83
        
           check int "Route counts match"

     

       84
       84
       -
             (List.length (Gpx.Gpx_doc.get_routes gpx_unix)) (List.length (Gpx.Gpx_doc.get_routes gpx_eio));

     

       84
       84
       +
             (List.length (Gpx.Doc.routes gpx_unix)) (List.length (Gpx.Doc.routes gpx_eio));

     

       85
       85
        
           check int "Track counts match"

     

       86
       86
       -
             (List.length (Gpx.Gpx_doc.get_tracks gpx_unix)) (List.length (Gpx.Gpx_doc.get_tracks gpx_eio))

     

       86
       86
       +
             (List.length (Gpx.Doc.tracks gpx_unix)) (List.length (Gpx.Doc.tracks gpx_eio))

     

       87
       87
        
         | Error _, Error _ ->

     

       88
       88
        
           (* Both failed - that's consistent *)

     

       89
       89
        
           check bool "Both Unix and Eio failed consistently" true true

     
···

       106
       106
        
                 check bool "Round-trip preserves basic structure" true

     

       107
       107
        
                   (compare_gpx_basic gpx_original gpx_roundtrip);

     

       108
       108
        
                 check string "Creator preserved" 

     

       109
       109
       -
                   (Gpx.Gpx_doc.get_creator gpx_original) (Gpx.Gpx_doc.get_creator gpx_roundtrip)

     

       109
       109
       +
                   (Gpx.Doc.creator gpx_original) (Gpx.Doc.creator gpx_roundtrip)

     

       110
       110
        
               | Error _ ->

     

       111
       111
        
                 failf "Round-trip parse failed for %s" filename)

     

       112
       112
        
            | Error _ ->

+11 -12

test/test_gpx.ml

···

       25
       25
        
       

     

       26
       26
        
       let test_gpx_creation () =

     

       27
       27
        
         let creator = "test" in

     

       28
       28
       -
         let gpx = Gpx_doc.empty ~creator in

     

       29
       29
       -
         assert (Gpx_doc.get_creator gpx = creator);

     

       30
       30
       -
         assert (Gpx_doc.get_version gpx = "1.1");

     

       31
       31
       -
         assert (Gpx_doc.get_waypoints gpx = []);

     

       28
       28
       +
         let gpx = Doc.empty ~creator in

     

       29
       29
       +
         assert (Doc.creator gpx = creator);

     

       30
       30
       +
         assert (Doc.version gpx = "1.1");

     

       31
       31
       +
         assert (Doc.waypoints gpx = []);

     

       32
       32
        
         

     

       33
       33
        
         Printf.printf "✓ GPX creation tests passed\n"

     

       34
       34
        
       

     
···

       43
       43
        
         

     

       44
       44
        
         match parse_string gpx_xml with

     

       45
       45
        
         | Ok gpx ->

     

       46
       46
       -
           assert (Gpx_doc.get_creator gpx = "test");

     

       47
       47
       -
           let waypoints = Gpx_doc.get_waypoints gpx in

     

       46
       46
       +
           assert (Doc.creator gpx = "test");

     

       47
       47
       +
           let waypoints = Doc.waypoints gpx in

     

       48
       48
        
           assert (List.length waypoints = 1);

     

       49
       49
        
           let wpt = List.hd waypoints in

     

       50
       50
       -
           assert (Waypoint.get_name wpt = Some "San Francisco");

     

       50
       50
       +
           assert (Waypoint.name wpt = Some "San Francisco");

     

       51
       51
        
           Printf.printf "✓ Simple parsing tests passed\n"

     

       52
       52
        
         | Error e ->

     

       53
       53
        
           Printf.printf "✗ Parsing failed: %s\n" (Error.to_string e);

     
···

       57
       57
        
         let lat = Result.get_ok (Coordinate.latitude 37.7749) in

     

       58
       58
        
         let lon = Result.get_ok (Coordinate.longitude (-122.4194)) in

     

       59
       59
        
         let wpt = Waypoint.make lat lon in

     

       60
       60
       -
         let wpt = Waypoint.with_name wpt "Test Point" in

     

       61
       61
       -
         let wpt = Waypoint.with_description wpt "A test waypoint" in

     

       62
       62
       -
         let gpx = Gpx_doc.empty ~creator:"test" in

     

       63
       63
       -
         let gpx = Gpx_doc.add_waypoint gpx wpt in

     

       60
       60
       +
         let wpt = { wpt with name = Some "Test Point"; desc = Some "A test waypoint" } in

     

       61
       61
       +
         let gpx = Doc.empty ~creator:"test" in

     

       62
       62
       +
         let gpx = Doc.add_waypoint gpx wpt in

     

       64
       63
        
         

     

       65
       64
        
         match write_string gpx with

     

       66
       65
        
         | Ok xml_string ->

     
···

       72
       71
        
           assert false

     

       73
       72
        
       

     

       74
       73
        
       let test_validation () =

     

       75
       75
       -
         let gpx = Gpx_doc.empty ~creator:"" in

     

       74
       74
       +
         let gpx = Doc.empty ~creator:"" in

     

       76
       75
        
         let validation = validate_gpx gpx in

     

       77
       76
        
         assert (not validation.is_valid);

     

       78
       77
        
         let errors = List.filter (fun issue -> issue.level = `Error) validation.issues in

Compare changes