diff options
Diffstat (limited to 'sheet.ml')
| -rwxr-xr-x | sheet.ml | 42 |
1 files changed, 23 insertions, 19 deletions
@@ -21,6 +21,9 @@ module Raw = struct sink : Cell.Set.t; (** All the cell which references this one *)
}
+ (** The sheet is a map which always contains evaluated values. When a cell is
+ updated, all the cell which references this value are also updated.
+ *)
and t = content Map.t
(** An empty cell which does contains nothing *)
@@ -30,39 +33,37 @@ module Raw = struct sink = Cell.Set.empty;
}
-
let create = Map.empty
- let get_value (id: cell) t = begin
+ let get_value id t = begin
try (Map.find id t).value
with Not_found -> ScTypes.Result ScTypes.Undefined
end
- let get_expr (id: cell) t = begin
+ let get_expr id t = begin
try (Map.find id t).expr
- with Not_found -> Expression.load @@ UTF8.empty
+ with Not_found -> empty_cell.expr
end
- (** Extract a value from a reference. *)
- let get_ref (from:cell) (t:t) : ScTypes.refs -> ScTypes.types = begin
+ (** Extract a value from a reference.
+ This function is given to the evaluator for getting the values from a reference.
+ *)
+ let get_ref from t ref = begin
let extract_values = begin function
| ScTypes.Result v -> v
| ScTypes.Error e -> raise e
end in
- begin function
- | ScTypes.Cell c ->
- let coord = Cell.to_pair c in
- if coord = from then raise Cycle; extract_values (get_value coord t)
- | ScTypes.Range _ as r ->
- ScTypes.Refs.collect r
- |> List.map (fun x -> if x = from then raise Cycle; extract_values (get_value x t))
- |> (fun x -> ScTypes.List x)
- end
+ ScTypes.Refs.collect ref
+ |> ScTypes.Refs.map (fun coord -> extract_values (get_value coord t))
+
end
- (** Update the value for the given cell *)
+ (** Update the value for the given cell.
+ Evaluate the new expression and compare it with the previous value.
+ @return the map updated if the result differ.
+ *)
let update cell content t = begin
let new_val = Expression.eval content.expr (get_ref cell t) in
if not (ScTypes.Result.(=) new_val content.value) then
@@ -73,8 +74,11 @@ module Raw = struct end
(** Parse all the successors from [init] and call [f] for each of them.
+
+ As long as [f] return [Some _], the cell successors will also be updated.
+
[f] is called only once for each successor.
- @return all the successors collected
+ @return all the successors collected, and the map updated.
*)
let successors (f:(cell -> content -> t -> t option)) (init:content) (state:Cell.Set.t * t) = begin
let rec fold cell (succ, t) = begin
@@ -82,7 +86,8 @@ module Raw = struct (* The element has already been parsed, do not cycle *)
(succ, t)
else (
- (* Map.find cannot raise Not_found here *)
+ (* Map.find cannot raise Not_found here : we look for a successor from a registered cell.
+ *)
let content = Map.find cell t in
match f cell content t with
| None -> (succ, t)
@@ -176,7 +181,6 @@ module Raw = struct add_element id f t
end
-
let paste id shift content t = begin
let expr = Expression.shift shift content.expr in
let f cell t =
|