1use algebra::Field;
  2use r1cs_core::{ConstraintSystem, SynthesisError};
  3use std::borrow::Borrow;
  4
  5pub trait AllocGadget<V, ConstraintF: Field>
  6where
  7    Self: Sized,
  8    V: ?Sized,
  9{
 10    fn alloc<F, T, CS: ConstraintSystem<ConstraintF>>(cs: CS, f: F) -> Result<Self, SynthesisError>
 11    where
 12        F: FnOnce() -> Result<T, SynthesisError>,
 13        T: Borrow<V>;
 14
 15    fn alloc_checked<F, T, CS: ConstraintSystem<ConstraintF>>(
 16        cs: CS,
 17        f: F,
 18    ) -> Result<Self, SynthesisError>
 19    where
 20        F: FnOnce() -> Result<T, SynthesisError>,
 21        T: Borrow<V>,
 22    {
 23        Self::alloc(cs, f)
 24    }
 25
 26    fn alloc_input<F, T, CS: ConstraintSystem<ConstraintF>>(
 27        cs: CS,
 28        f: F,
 29    ) -> Result<Self, SynthesisError>
 30    where
 31        F: FnOnce() -> Result<T, SynthesisError>,
 32        T: Borrow<V>;
 33
 34    fn alloc_input_checked<F, T, CS: ConstraintSystem<ConstraintF>>(
 35        cs: CS,
 36        f: F,
 37    ) -> Result<Self, SynthesisError>
 38    where
 39        F: FnOnce() -> Result<T, SynthesisError>,
 40        T: Borrow<V>,
 41    {
 42        Self::alloc_input(cs, f)
 43    }
 44}
 45
 46impl<I, ConstraintF: Field, A: AllocGadget<I, ConstraintF>> AllocGadget<[I], ConstraintF>
 47    for Vec<A>
 48{
 49    fn alloc<F, T, CS: ConstraintSystem<ConstraintF>>(
 50        mut cs: CS,
 51        f: F,
 52    ) -> Result<Self, SynthesisError>
 53    where
 54        F: FnOnce() -> Result<T, SynthesisError>,
 55        T: Borrow<[I]>,
 56    {
 57        let mut vec = Vec::new();
 58        for (i, value) in f()?.borrow().iter().enumerate() {
 59            vec.push(A::alloc(&mut cs.ns(|| format!("value_{}", i)), || {
 60                Ok(value)
 61            })?);
 62        }
 63        Ok(vec)
 64    }
 65
 66    fn alloc_input<F, T, CS: ConstraintSystem<ConstraintF>>(
 67        mut cs: CS,
 68        f: F,
 69    ) -> Result<Self, SynthesisError>
 70    where
 71        F: FnOnce() -> Result<T, SynthesisError>,
 72        T: Borrow<[I]>,
 73    {
 74        let mut vec = Vec::new();
 75        for (i, value) in f()?.borrow().iter().enumerate() {
 76            vec.push(A::alloc_input(
 77                &mut cs.ns(|| format!("value_{}", i)),
 78                || Ok(value),
 79            )?);
 80        }
 81        Ok(vec)
 82    }
 83
 84    fn alloc_checked<F, T, CS: ConstraintSystem<ConstraintF>>(
 85        mut cs: CS,
 86        f: F,
 87    ) -> Result<Self, SynthesisError>
 88    where
 89        F: FnOnce() -> Result<T, SynthesisError>,
 90        T: Borrow<[I]>,
 91    {
 92        let mut vec = Vec::new();
 93        for (i, value) in f()?.borrow().iter().enumerate() {
 94            vec.push(A::alloc_checked(
 95                &mut cs.ns(|| format!("value_{}", i)),
 96                || Ok(value),
 97            )?);
 98        }
 99        Ok(vec)
100    }
101
102    fn alloc_input_checked<F, T, CS: ConstraintSystem<ConstraintF>>(
103        mut cs: CS,
104        f: F,
105    ) -> Result<Self, SynthesisError>
106    where
107        F: FnOnce() -> Result<T, SynthesisError>,
108        T: Borrow<[I]>,
109    {
110        let mut vec = Vec::new();
111        for (i, value) in f()?.borrow().iter().enumerate() {
112            vec.push(A::alloc_input_checked(
113                &mut cs.ns(|| format!("value_{}", i)),
114                || Ok(value),
115            )?);
116        }
117        Ok(vec)
118    }
119}