efl

1
class Complex extends Efl.Object {
2
   data: Complex_Data;
3
   methods {
4
      // container test
5
      inptrcont @beta {
6
         params {
7
           l: list<string>;
8
         }
9
      }
10
      inclasscont @beta {
11
         params {
12
           l: list<Efl.Object>;
13
         }
14
      }
15
      incontcont @beta {
16
         params {
17
           l: list<list<string>>;
18
         }
19
      }
20
      incontcontown @beta {
21
         params {
22
           l: list<list<string>> @move;
23
         }
24
      }
25
      incontowncontown @beta {
26
         params {
27
           l: list<list<string> @move> @move;
28
         }
29
      }
30
      incontowncont @beta {
31
         params {
32
           l: list<list<string> @move>;
33
         }
34
      }
35
      instringcont @beta {
36
         params {
37
           l: list<string>;
38
         }
39
      }
40
      instringowncont @beta {
41
         params {
42
           l: list<mstring @move>;
43
         }
44
      }
45
      instringcontown @beta {
46
         params {
47
           l: list<string> @move;
48
         }
49
      }
50
      inarray {
51
         [[Docs for method inarray. @since 1.66]]
52
         params {
53
           l: array<string>;
54
         }
55
      }
56
      inarrayown {
57
         [[Docs for method inarrayown. @since 1.66]]
58
         params {
59
           l: array<string> @move;
60
         }
61
      }
62
      inhash @beta {
63
         params {
64
           l: hash<string, string>;
65
         }
66
      }
67
      inhashown @beta {
68
         params {
69
           l: hash<string, string> @move;
70
         }
71
      }
72
      initerator {
73
         [[Docs for method initerator. @since 1.66]]
74
         params {
75
           l: iterator<int>;
76
         }
77
      }
78
      initeratorown {
79
         [[Docs for method initeratorown. @since 1.66]]
80
         params {
81
           l: iterator<int> @move;
82
         }
83
      }
84
      inaccessor {
85
         [[Docs for method inacessor. @since 1.66]]
86
         params {
87
           l: accessor<int>;
88
         }
89
      }
90
      inaccessorown {
91
         [[Docs for method inaccessorown. @since 1.66]]
92
         params {
93
           l: accessor<int> @move;
94
         }
95
      }
96
      // out
97
      outclasscont @beta {
98
         params {
99
           @out l: list<Efl.Object>;
100
         }
101
      }
102
      outcontcont @beta {
103
         params {
104
           @out l: list<list<string>>;
105
         }
106
      }
107
      outcontcontown @beta {
108
         params {
109
           @out l: list<list<string>> @move;
110
         }
111
      }
112
      outcontowncontown @beta {
113
         params {
114
           @out l: list<list<string> @move> @move;
115
         }
116
      }
117
      outcontowncont @beta {
118
         params {
119
           @out l: list<list<string> @move>;
120
         }
121
      }
122
      outstringcont @beta {
123
         params {
124
           @out l: list<string>;
125
         }
126
      }
127
      outstringowncont @beta {
128
         params {
129
           @out l: list<mstring @move>;
130
         }
131
      }
132
      outstringcontown @beta {
133
         params {
134
           @out l: list<string> @move;
135
         }
136
      }
137
      outarray {
138
         [[Docs for method outarray. @since 1.66]]
139
         params {
140
           @out l: array<string>;
141
         }
142
      }
143
      outarrayown {
144
         [[Docs for method outarryown. @since 1.66]]
145
         params {
146
           @out l: array<string> @move;
147
         }
148
      }
149
      outhash @beta {
150
         params {
151
           @out l: hash<string, string>;
152
         }
153
      }
154
      outhashown @beta {
155
         params {
156
           @out l: hash<string, string> @move;
157
         }
158
      }
159
      outiterator {
160
         [[Docs for method outiterator. @since 1.66]]
161
         params {
162
           @out l: iterator<int>;
163
         }
164
      }
165
      outiteratorown {
166
         [[Docs for method outiteratorown. @since 1.66]]
167
         params {
168
           @out l: iterator<int> @move;
169
         }
170
      }
171
      outaccessor {
172
         [[Docs for method outaccessor. @since 1.66]]
173
         params {
174
           @out l: accessor<int>;
175
         }
176
      }
177
      outaccessorown {
178
         [[Docs for method outaccessorown. @since 1.66]]
179
         params {
180
           @out l: accessor<int> @move;
181
         }
182
      }
183
      foo @beta {
184
         params {
185
            l: list<string>;
186
         }
187
      }
188
      bar {
189
         [[Docs for method bar. @since 1.66]]
190
         return: array<string>;
191
      }
192
      wrapper_r {
193
         [[Docs for method wrapper_r. @since 1.66]]
194
         return: Complex;
195
      }
196
      wrapper_in {
197
         [[Docs for method wrapper_in. @since 1.66]]
198
         params {
199
            @in a1: Complex;
200
         }
201
      }
202
      wrapper_inout {
203
         [[Docs for method wrapper_inout. @since 1.66]]
204
         params {
205
            @inout a1: Complex;
206
         }
207
      }
208
      wrapper_out {
209
         [[Docs for method wrapper_out. @since 1.66]]
210
         params {
211
            @out a1: Complex;
212
         }
213
      }
214
   }
215
}
216

217