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

use elrond_codec::{EncodeError, TopEncode};

use crate::{
    api::{ErrorApi, LogApi, ManagedTypeApi},
    err_msg,
    types::{ManagedBuffer, ManagedType, ManagedVec},
};

pub fn event_topic_accumulator<A>(
    api: A,
    event_identifier: &[u8],
) -> ManagedVec<A, ManagedBuffer<A>>
where
    A: ErrorApi + ManagedTypeApi,
{
    let mut accumulator = ManagedVec::new(api.clone());
    accumulator.push(ManagedBuffer::new_from_bytes(api, event_identifier));
    accumulator
}

pub fn serialize_event_topic<A, T>(accumulator: &mut ManagedVec<A, ManagedBuffer<A>>, topic: T)
where
    A: ErrorApi + ManagedTypeApi,
    T: TopEncode,
{
    let mut topic_buffer = ManagedBuffer::new(accumulator.type_manager());
    topic.top_encode_or_exit(
        &mut topic_buffer,
        accumulator.type_manager(),
        serialize_log_topic_exit,
    );
    accumulator.push(topic_buffer);
}

#[inline(always)]
fn serialize_log_topic_exit<A>(api: A, encode_err: EncodeError) -> !
where
    A: ErrorApi + ManagedTypeApi + 'static,
{
    let mut message_buffer =
        ManagedBuffer::new_from_bytes(api.clone(), err_msg::LOG_TOPIC_ENCODE_ERROR);
    message_buffer.append_bytes(encode_err.message_bytes());
    api.signal_error_from_buffer(message_buffer.get_raw_handle())
}

pub fn serialize_log_data<T, A>(api: A, data: T) -> ManagedBuffer<A>
where
    T: TopEncode,
    A: ErrorApi + ManagedTypeApi + Clone + 'static,
{
    let mut data_buffer = ManagedBuffer::new(api.clone());
    data.top_encode_or_exit(&mut data_buffer, api, serialize_log_data_exit);
    data_buffer
}

#[inline(always)]
fn serialize_log_data_exit<A>(api: A, encode_err: EncodeError) -> !
where
    A: ErrorApi + ManagedTypeApi + 'static,
{
    let mut message_buffer =
        ManagedBuffer::new_from_bytes(api.clone(), err_msg::LOG_DATA_ENCODE_ERROR);
    message_buffer.append_bytes(encode_err.message_bytes());
    api.signal_error_from_buffer(message_buffer.get_raw_handle())
}

pub fn write_log<L, A>(api: L, topics: &ManagedVec<A, ManagedBuffer<A>>, data: &ManagedBuffer<A>)
where
    L: LogApi,
    A: ErrorApi + ManagedTypeApi,
{
    api.managed_write_log(topics.get_raw_handle(), data.get_raw_handle());
}