···

       
118
       
 
       
  { collection; file; event; calendar }

     

       
119
       
 
       


     

       
120
       
 
       
let events_of_icalendar collection ~file calendar =

     

       
121
       
-
       
  List.filter_map

     

       
122
       
-
       
    (function

     

       
123
       
-
       
      | `Event event -> Some { collection; file; event; calendar } | _ -> None)

     

       
124
       
-
       
    (snd calendar)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
125
       
 
       


     

       
126
       
 
       
let to_ical_event t = t.event

     

       
127
       
 
       
let to_ical_calendar t = t.calendar

     
···

       
200
       
 
       
let get_recurrence t = Option.map (fun r -> snd r) t.event.rrule

     

       
201
       
 
       
let get_collection t = t.collection

     

       
202
       
 
       
let get_file t = t.file

     

       
203
       
-
       


     

       
204
       
-
       
let get_recurrence_ids t =

     

       
205
       
-
       
  let _, recurrence_ids =

     

       
206
       
-
       
    match

     

       
207
       
-
       
      List.partition (function `Event _ -> true | _ -> false) (snd t.calendar)

     

       
208
       
-
       
    with

     

       
209
       
-
       
    | `Event hd :: tl, _ ->

     

       
210
       
-
       
        (hd, List.map (function `Event e -> e | _ -> assert false) tl)

     

       
211
       
-
       
    | _ -> assert false

     

       
212
       
-
       
  in

     

       
213
       
-
       
  recurrence_ids

     

       
214
       
 
       


     

       
215
       
 
       
type comparator = t -> t -> int

     

       
216
       
 
       


     
···

       
627
       
 
       
      in

     

       
628
       
 
       
      let generator =

     

       
629
       
 
       
        let ical_event = to_ical_event event in

     

       
630
       
-
       
        let recurrence_ids = get_recurrence_ids event in

     

       
631
       
-
       
        Fmt.pr "Event:\n%s\n" (format_event ~format:`Entries (clone_with_event event ical_event));

     

       
632
       
-
       
        List.iter (fun e ->

     

       
633
       
-
       
          Fmt.pr "Recurrent ID event:\n%s\n" (format_event ~format:`Entries (clone_with_event event e))) recurrence_ids;

     

       
634
       
-
       
        recur_events ~recurrence_ids ical_event

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
635
       
 
       
      in

     

       
636
       
 
       
      collect generator []

     

···

       
118
       
 
       
  { collection; file; event; calendar }

     

       
119
       
 
       


     

       
120
       
 
       
let events_of_icalendar collection ~file calendar =

     

       
121
       
+
       
  let remove_dup_ids lst =

     

       
122
       
+
       
    let rec aux acc = function

     

       
123
       
+
       
      | [] -> acc

     

       
124
       
+
       
      | x :: xs ->

     

       
125
       
+
       
          if List.exists (fun r -> r.uid = x.uid) acc then aux acc xs

     

       
126
       
+
       
          else aux (x :: acc) xs

     

       
127
       
+
       
    in

     

       
128
       
+
       
    aux [] lst

     

       
129
       
+
       
  in

     

       
130
       
+
       
  let events =

     

       
131
       
+
       
    List.filter_map

     

       
132
       
+
       
      (function `Event event -> Some event | _ -> None)

     

       
133
       
+
       
      (snd calendar)

     

       
134
       
+
       
  in

     

       
135
       
+
       
  let events = remove_dup_ids events in

     

       
136
       
+
       
  List.map (function event -> { collection; file; event; calendar }) events

     

       
137
       
 
       


     

       
138
       
 
       
let to_ical_event t = t.event

     

       
139
       
 
       
let to_ical_calendar t = t.calendar

     
···

       
212
       
 
       
let get_recurrence t = Option.map (fun r -> snd r) t.event.rrule

     

       
213
       
 
       
let get_collection t = t.collection

     

       
214
       
 
       
let get_file t = t.file

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
215
       
 
       


     

       
216
       
 
       
type comparator = t -> t -> int

     

       
217
       
 
       


     
···

       
628
       
 
       
      in

     

       
629
       
 
       
      let generator =

     

       
630
       
 
       
        let ical_event = to_ical_event event in

     

       
631
       
+
       
        (* The first event is the non recurrence-id one *)

     

       
632
       
+
       
        let _, other_events =

     

       
633
       
+
       
          match

     

       
634
       
+
       
            List.partition

     

       
635
       
+
       
              (function `Event _ -> true | _ -> false)

     

       
636
       
+
       
              (snd event.calendar)

     

       
637
       
+
       
          with

     

       
638
       
+
       
          | `Event hd :: tl, _ ->

     

       
639
       
+
       
              (hd, List.map (function `Event e -> e | _ -> assert false) tl)

     

       
640
       
+
       
          | _ -> assert false

     

       
641
       
+
       
        in

     

       
642
       
+
       
        Fmt.pr "Event:\n%s\n"

     

       
643
       
+
       
          (format_event ~format:`Entries (clone_with_event event ical_event));

     

       
644
       
+
       
        List.iter

     

       
645
       
+
       
          (fun e ->

     

       
646
       
+
       
            Fmt.pr "Recurrent ID event:\n%s\n"

     

       
647
       
+
       
              (format_event ~format:`Entries (clone_with_event event e)))

     

       
648
       
+
       
          other_events;

     

       
649
       
+
       
        (* Icalendar filters for equal uids *)

     

       
650
       
+
       
        recur_events ~recurrence_ids:other_events ical_event

     

       
651
       
 
       
      in

     

       
652
       
 
       
      collect generator []

     

···

       
72
       
 
       
val get_recurrence : t -> Icalendar.recurrence option

     

       
73
       
 
       
val get_collection : t -> Collection.t

     

       
74
       
 
       
val get_file : t -> Eio.Fs.dir_ty Eio.Path.t

     

       
75
       
-
       
val get_recurrence_ids : t -> Icalendar.event list

     

       
76
       
 
       


     

       
77
       
 
       
type comparator = t -> t -> int

     

       
78
       
 
       
(** Event comparator function type *)

     

···

       
72
       
 
       
val get_recurrence : t -> Icalendar.recurrence option

     

       
73
       
 
       
val get_collection : t -> Collection.t

     

       
74
       
 
       
val get_file : t -> Eio.Fs.dir_ty Eio.Path.t

     

       
0
       
 
       

     

       
75
       
 
       


     

       
76
       
 
       
type comparator = t -> t -> int

     

       
77
       
 
       
(** Event comparator function type *)