use primitives::{
algebra::{
elliptic_curve::Curve,
field::{binary::Gf2_128, mersenne::Mersenne107},
},
correlated_randomness::{
bundler::{errors::BundlerError, BundleIterator},
dabits::DaBit,
singlets::Singlet,
stream::NextVecIterator,
triples::Triple,
},
types::identifiers::Named,
};
use crate::{
circuit::preprocessing::{CircuitPreprocessing, FieldCircuitPreprocessing},
errors::AbortError,
preprocessing::{NextDaBit, NextDaBits, NextSinglet, NextSinglets, NextTriple, NextTriples},
};
pub struct PreprocessingIterator<C: Curve> {
pub base_field_dabits: NextVecIterator<DaBit<C::BaseField>, AbortError>,
pub base_field_singlets: NextVecIterator<Singlet<C::BaseField>, AbortError>,
pub base_field_triples: NextVecIterator<Triple<C::BaseField>, AbortError>,
pub binary_singlets: NextVecIterator<Singlet<Gf2_128>, AbortError>,
pub binary_triples: NextVecIterator<Triple<Gf2_128>, AbortError>,
pub mersenne107_dabits: NextVecIterator<DaBit<Mersenne107>, AbortError>,
pub mersenne107_singlets: NextVecIterator<Singlet<Mersenne107>, AbortError>,
pub mersenne107_triples: NextVecIterator<Triple<Mersenne107>, AbortError>,
pub scalar_dabits: NextVecIterator<DaBit<C::Scalar>, AbortError>,
pub scalar_singlets: NextVecIterator<Singlet<C::Scalar>, AbortError>,
pub scalar_triples: NextVecIterator<Triple<C::Scalar>, AbortError>,
}
impl<C: Curve> BundleIterator for PreprocessingIterator<C> {
type Size = CircuitPreprocessing;
fn len(&self) -> CircuitPreprocessing {
CircuitPreprocessing {
bit_singlets: self.binary_singlets.len(),
bit_triples: self.binary_triples.len(),
base_field: FieldCircuitPreprocessing {
singlets: self.base_field_singlets.len(),
triples: self.base_field_triples.len(),
dabits: self.base_field_dabits.len(),
},
scalar: FieldCircuitPreprocessing {
singlets: self.scalar_singlets.len(),
triples: self.scalar_triples.len(),
dabits: self.scalar_dabits.len(),
},
mersenne107: FieldCircuitPreprocessing {
singlets: self.mersenne107_singlets.len(),
triples: self.mersenne107_triples.len(),
dabits: self.mersenne107_dabits.len(),
},
}
}
fn is_empty(&self) -> bool {
self.base_field_dabits.len() == 0
&& self.base_field_singlets.len() == 0
&& self.base_field_triples.len() == 0
&& self.binary_singlets.len() == 0
&& self.binary_triples.len() == 0
&& self.mersenne107_dabits.len() == 0
&& self.mersenne107_singlets.len() == 0
&& self.mersenne107_triples.len() == 0
&& self.scalar_dabits.len() == 0
&& self.scalar_singlets.len() == 0
&& self.scalar_triples.len() == 0
}
}
macro_rules! next_preprocessing_item {
($( ($fn:ident, $iter:ident, $ret:ty, $ty:ty, $kind:literal) ),* $(,)?) => {
$(
pub fn $fn(&mut self) -> Result<$ret, BundlerError> {
self.$iter.next().ok_or_else(|| {
BundlerError::InsufficientPreprocessing(
format!("{} {}", <$ty>::get_name(), $kind),
)
})
}
)*
};
}
macro_rules! next_n_preprocessing_items {
($( ($fn:ident, $iter:ident, $ret:ty, $ty:ty, $kind:literal) ),* $(,)?) => {
$(
pub fn $fn(&mut self, n: usize) -> Result<$ret, BundlerError> {
self.$iter.next_n(n).ok_or_else(|| {
BundlerError::InsufficientPreprocessing(
format!("{} {} (requested {}, available {})", <$ty>::get_name(), $kind, n, self.$iter.len()),
)
})
}
)*
};
}
impl<C: Curve> PreprocessingIterator<C> {
next_preprocessing_item!(
(next_base_field_dabit, base_field_dabits, NextDaBit<C::BaseField>, C::BaseField, "dabits"),
(next_base_field_singlet, base_field_singlets, NextSinglet<C::BaseField>, C::BaseField, "singlets"),
(next_base_field_triple, base_field_triples, NextTriple<C::BaseField>, C::BaseField, "triples"),
(next_bit_singlet, binary_singlets, NextSinglet<Gf2_128>, Gf2_128, "singlets"),
(next_bit_triple, binary_triples, NextTriple<Gf2_128>, Gf2_128, "triples"),
(next_mersenne107_dabit, mersenne107_dabits, NextDaBit<Mersenne107>, Mersenne107, "dabits"),
(next_mersenne107_singlet, mersenne107_singlets, NextSinglet<Mersenne107>, Mersenne107, "singlets"),
(next_mersenne107_triple, mersenne107_triples, NextTriple<Mersenne107>, Mersenne107, "triples"),
(next_scalar_dabit, scalar_dabits, NextDaBit<C::Scalar>, C::Scalar, "dabits"),
(next_scalar_singlet, scalar_singlets, NextSinglet<C::Scalar>, C::Scalar, "singlets"),
(next_scalar_triple, scalar_triples, NextTriple<C::Scalar>, C::Scalar, "triples"),
);
next_n_preprocessing_items!(
(next_n_base_field_dabits, base_field_dabits, NextDaBits<C::BaseField>, C::BaseField, "dabits"),
(next_n_base_field_singlets, base_field_singlets, NextSinglets<C::BaseField>, C::BaseField, "singlets"),
(next_n_base_field_triples, base_field_triples, NextTriples<C::BaseField>, C::BaseField, "triples"),
(next_n_bit_singlets, binary_singlets, NextSinglets<Gf2_128>, Gf2_128, "singlets"),
(next_n_bit_triples, binary_triples, NextTriples<Gf2_128>, Gf2_128, "triples"),
(next_n_mersenne107_dabits, mersenne107_dabits, NextDaBits<Mersenne107>, Mersenne107, "dabits"),
(next_n_mersenne107_singlets, mersenne107_singlets, NextSinglets<Mersenne107>, Mersenne107, "singlets"),
(next_n_mersenne107_triples, mersenne107_triples, NextTriples<Mersenne107>, Mersenne107, "triples"),
(next_n_scalar_dabits, scalar_dabits, NextDaBits<C::Scalar>, C::Scalar, "dabits"),
(next_n_scalar_singlets, scalar_singlets, NextSinglets<C::Scalar>, C::Scalar, "singlets"),
(next_n_scalar_triples, scalar_triples, NextTriples<C::Scalar>, C::Scalar, "triples"),
);
}
impl<C: Curve> std::fmt::Debug for PreprocessingIterator<C> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "PreprocessingIterator with len: {:?}", self.len())
}
}