1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use crate::call_data::*;
use crate::*;
use elrond_codec::*;

pub trait AsyncCallArg: Sized {
	fn push_async_arg(&self, serializer: &mut CallDataSerializer) -> Result<(), SCError>;

	fn push_async_arg_exact(
		&self,
		_serializer: &mut CallDataSerializer,
		_expected_len: usize,
	) -> Result<(), SCError> {
		Err(SCError::from(&b"not supported"[..]))
	}
}

struct AsyncCallArgOutput<'c> {
	call_data_ser_ref: &'c mut CallDataSerializer,
}

impl<'c> AsyncCallArgOutput<'c> {
	#[inline]
	fn new(call_data_ser_ref: &'c mut CallDataSerializer) -> Self {
		AsyncCallArgOutput { call_data_ser_ref }
	}
}

impl<'c> TopEncodeOutput for AsyncCallArgOutput<'c> {
	fn set_slice_u8(self, bytes: &[u8]) {
		self.call_data_ser_ref.push_argument_bytes(bytes);
	}
}

impl<T> AsyncCallArg for T
where
	T: TopEncode,
{
	#[inline]
	fn push_async_arg(&self, serializer: &mut CallDataSerializer) -> Result<(), SCError> {
		self.top_encode(AsyncCallArgOutput::new(serializer))
			.map_err(|err| SCError::from(err))
	}
}

impl<T> AsyncCallArg for VarArgs<T>
where
	T: AsyncCallArg,
{
	fn push_async_arg(&self, serializer: &mut CallDataSerializer) -> Result<(), SCError> {
		for elem in self.0.iter() {
			elem.push_async_arg(serializer)?;
		}
		Ok(())
	}

	fn push_async_arg_exact(
		&self,
		serializer: &mut CallDataSerializer,
		expected_len: usize,
	) -> Result<(), SCError> {
		if self.len() != expected_len {
			return Err(SCError::from(err_msg::ARG_ASYNC_WRONG_NUMBER));
		}
		self.push_async_arg(serializer)?;
		Ok(())
	}
}

impl<T> AsyncCallArg for OptionalArg<T>
where
	T: AsyncCallArg,
{
	#[inline]
	fn push_async_arg(&self, serializer: &mut CallDataSerializer) -> Result<(), SCError> {
		if let OptionalArg::Some(t) = self {
			t.push_async_arg(serializer)?;
		}
		Ok(())
	}
}

macro_rules! multi_result_impls {
    ($(($mr:ident $($n:tt $name:ident)+) )+) => {
        $(
            impl<$($name),+> AsyncCallArg for $mr<$($name,)+>
            where
                $($name: AsyncCallArg,)+
            {
                #[inline]
                fn push_async_arg(&self, serializer: &mut CallDataSerializer) -> Result<(), SCError> {
                    $(
                        (self.0).$n.push_async_arg(serializer)?;
                    )+
                    Ok(())
                }
            }
        )+
    }
}

multi_result_impls! {
	(MultiResult1  0 T0)
	(MultiResult2  0 T0 1 T1)
	(MultiResult3  0 T0 1 T1 2 T2)
	(MultiResult4  0 T0 1 T1 2 T2 3 T3)
	(MultiResult5  0 T0 1 T1 2 T2 3 T3 4 T4)
	(MultiResult6  0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
	(MultiResult7  0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
	(MultiResult8  0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
	(MultiResult9  0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
	(MultiResult10 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
	(MultiResult11 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
	(MultiResult12 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
	(MultiResult13 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
	(MultiResult14 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
	(MultiResult15 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
	(MultiResult16 0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
}