lua-protobuf-rs 0.3.0

lua protobuf
Documentation 
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

pub mod enum_descriptor_proto;
pub mod enum_options;
pub mod enum_reserved_range;
pub mod enum_value_descriptor_proto;
pub mod enum_value_options;
pub mod extension_options;
pub mod extension_range;
pub mod field_descriptor_proto;
mod field_options;
pub mod file_descriptor_proto;
mod file_options;
mod location;
pub mod method_descriptor_proto;
mod method_options;
pub mod name_part;
pub mod oneof_descriptor_proto;
pub mod oneof_options;
pub mod reserved_range;
pub mod service_descriptor_proto;
mod source_code_info;
pub mod uninterpreted_option;

use crate::descriptor_proto::enum_descriptor_proto::LuaEnumDescriptorProto;
use crate::descriptor_proto::extension_range::LuaExtensionRange;
use crate::descriptor_proto::field_descriptor_proto::LuaFieldDescriptorProto;
use crate::descriptor_proto::oneof_descriptor_proto::LuaOneofDescriptorProto;
use crate::descriptor_proto::reserved_range::LuaReservedRange;
use crate::{
    add_message_dyn_trait_method, add_message_full_trait_method, add_message_trait_method,
};
use derive_more::{Deref, DerefMut, From, Into};
use mlua::prelude::LuaUserData;
use mlua::{MetaMethod, UserDataFields, UserDataMethods};
use protobuf::descriptor::DescriptorProto;

#[derive(PartialEq, Clone, Default, Debug, Deref, DerefMut, From, Into)]
pub struct LuaDescriptorProto(pub DescriptorProto);

impl LuaUserData for LuaDescriptorProto {
    fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
        fields.add_field_method_get("name", |_, this| Ok(this.name.clone()));

        fields.add_field_method_get("field", |_, this| {
            let field: Vec<LuaFieldDescriptorProto> = this
                .field
                .iter()
                .map(Clone::clone)
                .map(From::from)
                .collect();
            Ok(field)
        });

        fields.add_field_method_get("extension", |_, this| {
            let extension: Vec<LuaFieldDescriptorProto> = this
                .extension
                .iter()
                .map(Clone::clone)
                .map(From::from)
                .collect();
            Ok(extension)
        });

        fields.add_field_method_get("nested_type", |_, this| {
            let nested_type: Vec<LuaDescriptorProto> = this
                .nested_type
                .iter()
                .map(Clone::clone)
                .map(From::from)
                .collect();
            Ok(nested_type)
        });

        fields.add_field_method_get("enum_type", |_, this| {
            let enum_type: Vec<LuaEnumDescriptorProto> = this
                .enum_type
                .iter()
                .map(Clone::clone)
                .map(From::from)
                .collect();
            Ok(enum_type)
        });

        fields.add_field_method_get("extension_range", |_, this| {
            let extension_range: Vec<LuaExtensionRange> = this
                .extension_range
                .iter()
                .map(Clone::clone)
                .map(From::from)
                .collect();
            Ok(extension_range)
        });

        fields.add_field_method_get("oneof_decl", |_, this| {
            let oneof_decl: Vec<LuaOneofDescriptorProto> = this
                .oneof_decl
                .iter()
                .map(Clone::clone)
                .map(From::from)
                .collect();
            Ok(oneof_decl)
        });

        fields.add_field_method_get("reserved_range", |_, this| {
            let reserved_range: Vec<LuaReservedRange> = this
                .reserved_range
                .iter()
                .map(Clone::clone)
                .map(From::from)
                .collect();
            Ok(reserved_range)
        });

        fields.add_field_method_get("reserved_name", |_, this| Ok(this.reserved_name.clone()));
    }

    fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
        methods.add_meta_method(MetaMethod::ToString, |_, this, ()| Ok(this.to_string()));

        methods.add_method("name", |_, this, ()| Ok(this.name().to_string()));

        methods.add_method_mut("clear_name", |_, this, ()| {
            this.clear_name();
            Ok(())
        });

        methods.add_method_mut("set_name", |_, this, name: String| {
            this.set_name(name);
            Ok(())
        });

        methods.add_method_mut("mut_name", |_, this, ()| Ok(this.mut_name().clone()));

        methods.add_method_mut("take_name", |_, this, ()| Ok(this.take_name()));

        add_message_trait_method!(methods, DescriptorProto, LuaDescriptorProto);

        add_message_dyn_trait_method!(methods, DescriptorProto, LuaDescriptorProto);

        add_message_full_trait_method!(methods, DescriptorProto, LuaDescriptorProto);
    }
}