Source file gpx_io.ml

(** GPX Unix I/O operations *)


(** Result binding operators *)
let (let*) = Result.bind

(** Read GPX from file *)
let read_file ?(validate=false) filename =
  try
    let ic = open_in filename in
    let input = Xmlm.make_input (`Channel ic) in
    let result = Gpx.parse ~validate input in
    close_in ic;
    result
  with
  | Sys_error msg -> Error (Gpx.Error.io_error msg)
  | exn -> Error (Gpx.Error.io_error (Printexc.to_string exn))

(** Write GPX to file *)
let write_file ?(validate=false) filename gpx =
  try
    let oc = open_out filename in
    let dest = `Channel oc in
    let result = Gpx.write ~validate dest gpx in
    close_out oc;
    result
  with
  | Sys_error msg -> Error (Gpx.Error.io_error msg)
  | exn -> Error (Gpx.Error.io_error (Printexc.to_string exn))

(** Read GPX from stdin *)
let read_stdin ?(validate=false) () =
  let input = Xmlm.make_input (`Channel stdin) in
  Gpx.parse ~validate input

(** Write GPX to stdout *)
let write_stdout ?(validate=false) gpx =
  Gpx.write ~validate (`Channel stdout) gpx

(** Check if file exists and is readable *)
let file_exists filename =
  try
    let _ = Unix.stat filename in
    true
  with
  | Unix.Unix_error _ -> false

(** Get file size *)
let file_size filename =
  try
    let stats = Unix.stat filename in
    Ok stats.st_size
  with
  | Unix.Unix_error (errno, _, _) -> 
    Error (Gpx.Error.io_error (Unix.error_message errno))

(** Create backup of file before overwriting *)
let create_backup filename =
  if file_exists filename then
    let backup_name = filename ^ ".bak" in
    try
      let ic = open_in filename in
      let oc = open_out backup_name in
      let rec copy () =
        match input_char ic with
        | c -> output_char oc c; copy ()
        | exception End_of_file -> ()
      in
      copy ();
      close_in ic;
      close_out oc;
      Ok backup_name
    with
    | Sys_error msg -> Error (Gpx.Error.io_error msg)
    | exn -> Error (Gpx.Error.io_error (Printexc.to_string exn))
  else
    Ok ""

(** Write GPX to file with backup *)
let write_file_with_backup ?(validate=false) filename gpx =
  let* backup_name = create_backup filename in
  match write_file ~validate filename gpx with
  | Ok () -> Ok backup_name
  | Error _ as err ->
    (* Try to restore backup if write failed *)
    if backup_name <> "" && file_exists backup_name then (
      try
        Sys.rename backup_name filename
      with _ -> ()
    );
    err