1use crate::evaluate::{evaluate_reachable, EvaluationRunError};
2use crate::float::FloatError;
3use crate::{
4 Assignments, AtomStore, CertifiedF64, ConsumerId, EvaluationCache, ExprGraph, ExprId,
5 IsolationCache, PrecisionRequirements, ResolveError, ResolvedValues, StorageError,
6};
7
8#[derive(Debug, Eq, PartialEq)]
9pub struct Resolver;
10
11#[allow(clippy::new_without_default)]
12impl Resolver {
13 pub const fn new() -> Self {
14 Self
15 }
16
17 pub fn resolve_all(
18 &self,
19 graph: &ExprGraph,
20 atoms: &AtomStore,
21 requirements: &PrecisionRequirements,
22 assignments: &Assignments,
23 ) -> Result<(EvaluationCache, IsolationCache, ResolvedValues), ResolveError> {
24 let mut evaluation = EvaluationCache::new();
25 let mut isolation = IsolationCache::new();
26 let mut resolved = ResolvedValues::new();
27
28 for &(consumer, bits) in requirements.entries() {
29 let result = match assignments.get(consumer) {
30 None => Err(ResolveError::MissingAssignment { consumer }),
31 Some(expr) if graph.get(expr).is_none() => {
32 Err(ResolveError::UnknownExprId { consumer, expr })
33 }
34 Some(expr) => resolve_consumer(
35 consumer,
36 expr,
37 bits,
38 graph,
39 atoms,
40 &mut evaluation,
41 &mut isolation,
42 )
43 .map_err(ResolveError::Storage)?,
44 };
45 insert_consumer_result(&mut resolved, consumer, result)?;
46 }
47 Ok((evaluation, isolation, resolved))
48 }
49}
50
51fn insert_consumer_result(
52 resolved: &mut ResolvedValues,
53 consumer: ConsumerId,
54 result: Result<CertifiedF64, ResolveError>,
55) -> Result<(), ResolveError> {
56 resolved
57 .insert(consumer, result)
58 .map_err(ResolveError::Storage)
59}
60
61#[allow(clippy::too_many_arguments)]
62fn resolve_consumer(
63 consumer: ConsumerId,
64 expr: ExprId,
65 bits: crate::AbsoluteBits,
66 graph: &ExprGraph,
67 atoms: &AtomStore,
68 evaluation: &mut EvaluationCache,
69 isolation: &mut IsolationCache,
70) -> Result<Result<CertifiedF64, ResolveError>, StorageError> {
71 let value = match evaluate_reachable(expr, graph, atoms, evaluation) {
72 Ok(value) => value,
73 Err(EvaluationRunError::UnknownExpr(expr)) => {
74 return Ok(Err(ResolveError::UnknownExprId { consumer, expr }));
75 }
76 Err(EvaluationRunError::UnknownAtom { expr, atom }) => {
77 return Ok(Err(ResolveError::UnknownAtomId { expr, atom }));
78 }
79 Err(EvaluationRunError::Evaluation(error)) => {
80 return Ok(Err(local_evaluation_error(error)));
81 }
82 Err(EvaluationRunError::Storage(error)) => return Err(error),
83 };
84 match CertifiedF64::resolve(&value, expr, bits, isolation) {
85 Ok(value) => Ok(Ok(value)),
86 Err(FloatError::OutOfRange) => Ok(Err(ResolveError::FloatOutOfRange { consumer, expr })),
87 Err(FloatError::Bigint(error)) => Ok(Err(ResolveError::Bigint(error))),
88 Err(FloatError::Algnum(error)) => Ok(Err(ResolveError::Algnum(error))),
89 Err(FloatError::Storage(error)) => Err(error),
90 }
91}
92
93fn local_evaluation_error(error: crate::EvalError) -> ResolveError {
94 ResolveError::Evaluation(error)
95}