summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorBruno da Silva Belo <brunodasilvabelo@gmail.com>2019-10-16 11:26:03 -0300
committerLauro Moura <lauromoura@expertisesolutions.com.br>2019-10-16 16:10:58 -0300
commit4885e0764d6ea0ed542b90f9e02dd1eb5d1fa8d7 (patch)
tree5b16b3b83975897fbd4ef9b94624f0f6848204d9 /src
parent2ace33915b61339a8dcf0be046a8243310041241 (diff)
csharp: Updating eldbus_common docs.
Summary: ref T8361 Reviewers: lauromoura, felipealmeida, segfaultxavi, woohyun Reviewed By: lauromoura Subscribers: cedric, #reviewers, #committers Tags: #efl Maniphest Tasks: T8361 Differential Revision: https://phab.enlightenment.org/D10416
Diffstat (limited to 'src')
-rw-r--r--src/bindings/mono/eldbus_mono/eldbus_common.cs663
1 files changed, 661 insertions, 2 deletions
diff --git a/src/bindings/mono/eldbus_mono/eldbus_common.cs b/src/bindings/mono/eldbus_mono/eldbus_common.cs
index 80b1e25..99a7aef 100644
--- a/src/bindings/mono/eldbus_mono/eldbus_common.cs
+++ b/src/bindings/mono/eldbus_mono/eldbus_common.cs
@@ -2,182 +2,466 @@
2 2
3using System; 3using System;
4using System.Runtime.InteropServices; 4using System.Runtime.InteropServices;
5using System.ComponentModel;
5 6
6using static eldbus.EldbusMessageNativeFunctions; 7using static eldbus.EldbusMessageNativeFunctions;
7 8
8namespace eldbus 9namespace eldbus
9{ 10{
10 11/// <summary>
12/// Representation for Timeout flags.
13/// <para>Since EFL 1.23.</para>
14/// </summary>
11public static class Timeout 15public static class Timeout
12{ 16{
17 /// <summary>
18 /// Infinite flag.
19 /// <para>Since EFL 1.23.</para>
20 /// </summary>
13 public const int Infinite = 0x7fffffff; 21 public const int Infinite = 0x7fffffff;
14} 22}
15 23
24/// <summary>
25/// The path to an object.
26/// <para>Since EFL 1.23.</para>
27/// </summary>
16[StructLayout(LayoutKind.Sequential)] 28[StructLayout(LayoutKind.Sequential)]
17public struct ObjectPath 29public struct ObjectPath
18{ 30{
31 /// <summary>
32 /// The string of the path.
33 /// <para>Since EFL 1.23.</para>
34 /// </summary>
19 public string value; 35 public string value;
20 36
37 /// <summary>
38 /// Constructor
39 /// <para>Since EFL 1.23.</para>
40 /// </summary>
41 /// <param name="str">The string of the path.</param>
21 public ObjectPath(string str) 42 public ObjectPath(string str)
22 { 43 {
23 value = str; 44 value = str;
24 } 45 }
25 46
47 /// <summary>
48 /// Conversion operator of ObjectPath from string.
49 /// <para>Since EFL 1.23.</para>
50 /// </summary>
51 /// <param name="str">The string of the path.</param>
26 public static implicit operator ObjectPath(string str) 52 public static implicit operator ObjectPath(string str)
27 { 53 {
28 return new ObjectPath(str); 54 return new ObjectPath(str);
29 } 55 }
30 56
57 /// <summary>
58 /// Conversion operator of string from ObjectPath.
59 /// <para>Since EFL 1.23.</para>
60 /// </summary>
61 /// <param name="path">The ObjectPath to be converted.</param>
31 public static implicit operator string(ObjectPath path) 62 public static implicit operator string(ObjectPath path)
32 { 63 {
33 return path.value; 64 return path.value;
34 } 65 }
35} 66}
36 67
68/// <summary>
69/// String to a signature.
70/// <para>Since EFL 1.23.</para>
71/// </summary>
37[StructLayout(LayoutKind.Sequential)] 72[StructLayout(LayoutKind.Sequential)]
38public struct SignatureString 73public struct SignatureString
39{ 74{
75 /// <summary>
76 /// The string of the signature.
77 /// <para>Since EFL 1.23.</para>
78 /// </summary>
40 public string value; 79 public string value;
41 80
81 /// <summary>
82 /// Constructor.
83 /// <para>Since EFL 1.23.</para>
84 /// </summary>
85 /// <param name="str">The string of the signature.</param>
42 public SignatureString(string str) 86 public SignatureString(string str)
43 { 87 {
44 value = str; 88 value = str;
45 } 89 }
46 90
91 /// <summary>
92 /// Conversion operator of SignatureString from string.
93 /// <para>Since EFL 1.23.</para>
94 /// </summary>
95 /// <param name="str">The string of the signature.</param>
47 public static implicit operator SignatureString(string str) 96 public static implicit operator SignatureString(string str)
48 { 97 {
49 return new SignatureString(str); 98 return new SignatureString(str);
50 } 99 }
51 100
101 /// <summary>
102 /// Conversion operator of string from SignatureString.
103 /// <para>Since EFL 1.23.</para>
104 /// </summary>
105 /// <param name="sig">The SignatureString to be conversion.</param>
52 public static implicit operator string(SignatureString sig) 106 public static implicit operator string(SignatureString sig)
53 { 107 {
54 return sig.value; 108 return sig.value;
55 } 109 }
56} 110}
57 111
112/// <summary>
113/// Representation for Unix file descriptor.
114/// <para>Since EFL 1.23.</para>
115/// </summary>
58[StructLayout(LayoutKind.Sequential)] 116[StructLayout(LayoutKind.Sequential)]
59public struct UnixFd 117public struct UnixFd
60{ 118{
119 /// <summary>
120 /// The value of the file descriptor.
121 /// <para>Since EFL 1.23.</para>
122 /// </summary>
61 public Int32 value; 123 public Int32 value;
62 124
125 /// <summary>
126 /// Constructor.
127 /// <para>Since EFL 1.23.</para>
128 /// </summary>
129 /// <param name="fd">The file descriptor.</param>
63 public UnixFd(Int32 fd) 130 public UnixFd(Int32 fd)
64 { 131 {
65 value = fd; 132 value = fd;
66 } 133 }
67 134
135 /// <summary>
136 /// Conversion operator of UnixFd from Int32.
137 /// <para>Since EFL 1.23.</para>
138 /// </summary>
139 /// <param name="fd">The file descriptor.</param>
68 public static implicit operator UnixFd(Int32 fd) 140 public static implicit operator UnixFd(Int32 fd)
69 { 141 {
70 return new UnixFd(fd); 142 return new UnixFd(fd);
71 } 143 }
72 144
145 /// <summary>
146 /// Conversion operator of Int32 from UnixFd.
147 /// <para>Since EFL 1.23.</para>
148 /// </summary>
149 /// <param name="unix_fd">The UnixFd to be converted.</param>
73 public static implicit operator Int32(UnixFd unix_fd) 150 public static implicit operator Int32(UnixFd unix_fd)
74 { 151 {
75 return unix_fd.value; 152 return unix_fd.value;
76 } 153 }
77} 154}
78 155
79 156/// <summary>
157/// Arguments of EldBus.
158/// <para>Since EFL 1.23.</para>
159/// </summary>
80public static class Argument 160public static class Argument
81{ 161{
162 /// <summary>
163 /// The type of a byte.
164 /// <para>Since EFL 1.23.</para>
165 /// </summary>
82 public class ByteType 166 public class ByteType
83 { 167 {
168 /// <summary>
169 /// The code of the byte.
170 /// <para>Since EFL 1.23.</para>
171 /// </summary>
84 public const char Code = 'y'; 172 public const char Code = 'y';
173 /// <summary>
174 /// The signature of the byte.
175 /// <para>Since EFL 1.23.</para>
176 /// </summary>
85 public const string Signature = "y"; 177 public const string Signature = "y";
86 } 178 }
87 179
180 /// <summary>
181 /// The type of a boolean
182 /// <para>Since EFL 1.23.</para>
183 /// </summary>
88 public class BooleanType 184 public class BooleanType
89 { 185 {
186 /// <summary>
187 /// The code of the boolean.
188 /// <para>Since EFL 1.23.</para>
189 /// </summary>
90 public const char Code = 'b'; 190 public const char Code = 'b';
191 /// <summary>
192 /// The signature of the boolean.
193 /// <para>Since EFL 1.23.</para>
194 /// </summary>
91 public const string Signature = "b"; 195 public const string Signature = "b";
92 } 196 }
93 197
198 /// <summary>
199 /// The type of a Int16.
200 /// <para>Since EFL 1.23.</para>
201 /// </summary>
94 public class Int16Type 202 public class Int16Type
95 { 203 {
204 /// <summary>
205 /// The code of the Int16.
206 /// <para>Since EFL 1.23.</para>
207 /// </summary>
96 public const char Code = 'n'; 208 public const char Code = 'n';
209 /// <summary>
210 /// The signature of the Int16.
211 /// <para>Since EFL 1.23.</para>
212 /// </summary>
97 public const string Signature = "n"; 213 public const string Signature = "n";
98 } 214 }
99 215
216 /// <summary>
217 /// The type of an unsigned Int16.
218 /// <para>Since EFL 1.23.</para>
219 /// </summary>
100 public class UInt16Type 220 public class UInt16Type
101 { 221 {
222 /// <summary>
223 /// The code of the unsigned Int16.
224 /// <para>Since EFL 1.23.</para>
225 /// </summary>
102 public const char Code = 'q'; 226 public const char Code = 'q';
227 /// <summary>
228 /// The signature of the unsigned Int16.
229 /// <para>Since EFL 1.23.</para>
230 /// </summary>
103 public const string Signature = "q"; 231 public const string Signature = "q";
104 } 232 }
105 233
234 /// <summary>
235 /// The type of a Int32.
236 /// <para>Since EFL 1.23.</para>
237 /// </summary>
106 public class Int32Type 238 public class Int32Type
107 { 239 {
240 /// <summary>
241 /// The code of the Int32.
242 /// <para>Since EFL 1.23.</para>
243 /// </summary>
108 public const char Code = 'i'; 244 public const char Code = 'i';
245 /// <summary>
246 /// The signature of the Int32.
247 /// <para>Since EFL 1.23.</para>
248 /// </summary>
109 public const string Signature = "i"; 249 public const string Signature = "i";
110 } 250 }
111 251
252 /// <summary>
253 /// The type of an unsigned Int32.
254 /// <para>Since EFL 1.23.</para>
255 /// </summary>
112 public class UInt32Type 256 public class UInt32Type
113 { 257 {
258 /// <summary>
259 /// The code of the unsigned Int32.
260 /// <para>Since EFL 1.23.</para>
261 /// </summary>
114 public const char Code = 'u'; 262 public const char Code = 'u';
263 /// <summary>
264 /// The signature of the unsigned Int32.
265 /// <para>Since EFL 1.23.</para>
266 /// </summary>
115 public const string Signature = "u"; 267 public const string Signature = "u";
116 } 268 }
117 269
270 /// <summary>
271 /// The type of a Int64.
272 /// <para>Since EFL 1.23.</para>
273 /// </summary>
118 public class Int64Type 274 public class Int64Type
119 { 275 {
276 /// <summary>
277 /// The code of the Int64.
278 /// <para>Since EFL 1.23.</para>
279 /// </summary>
120 public const char Code = 'x'; 280 public const char Code = 'x';
281 /// <summary>
282 /// The signature of the Int64.
283 /// <para>Since EFL 1.23.</para>
284 /// </summary>
121 public const string Signature = "x"; 285 public const string Signature = "x";
122 } 286 }
123 287
288 /// <summary>
289 /// The type of an unsigned Int64.
290 /// <para>Since EFL 1.23.</para>
291 /// </summary>
124 public class UInt64Type 292 public class UInt64Type
125 { 293 {
294 /// <summary>
295 /// The code of the unsigned Int64.
296 /// <para>Since EFL 1.23.</para>
297 /// </summary>
126 public const char Code = 't'; 298 public const char Code = 't';
299 /// <summary>
300 /// The signature of the unsigned Int64.
301 /// <para>Since EFL 1.23.</para>
302 /// </summary>
127 public const string Signature = "t"; 303 public const string Signature = "t";
128 } 304 }
129 305
306 /// <summary>
307 /// The type of the double.
308 /// <para>Since EFL 1.23.</para>
309 /// </summary>
130 public class DoubleType 310 public class DoubleType
131 { 311 {
312 /// <summary>
313 /// The code of the double.
314 /// <para>Since EFL 1.23.</para>
315 /// </summary>
132 public const char Code = 'd'; 316 public const char Code = 'd';
317 /// <summary>
318 /// The signature of the double.
319 /// <para>Since EFL 1.23.</para>
320 /// </summary>
133 public const string Signature = "d"; 321 public const string Signature = "d";
134 } 322 }
135 323
324 /// <summary>
325 /// The type of a string.
326 /// <para>Since EFL 1.23.</para>
327 /// </summary>
136 public class StringType 328 public class StringType
137 { 329 {
330 /// <summary>
331 /// The code of the string.
332 /// <para>Since EFL 1.23.</para>
333 /// </summary>
138 public const char Code = 's'; 334 public const char Code = 's';
335 /// <summary>
336 /// The signature of the string.
337 /// <para>Since EFL 1.23.</para>
338 /// </summary>
139 public const string Signature = "s"; 339 public const string Signature = "s";
140 } 340 }
141 341
342 /// <summary>
343 /// The type of an object path.
344 /// <para>Since EFL 1.23.</para>
345 /// </summary>
142 public class ObjectPathType 346 public class ObjectPathType
143 { 347 {
348 /// <summary>
349 /// The code of the object path.
350 /// <para>Since EFL 1.23.</para>
351 /// </summary>
144 public const char Code = 'o'; 352 public const char Code = 'o';
353 /// <summary>
354 /// The signature of the object path.
355 /// <para>Since EFL 1.23.</para>
356 /// </summary>
145 public const string Signature = "o"; 357 public const string Signature = "o";
146 } 358 }
147 359
360 /// <summary>
361 /// The type of a signature.
362 /// <para>Since EFL 1.23.</para>
363 /// </summary>
148 public class SignatureType 364 public class SignatureType
149 { 365 {
366 /// <summary>
367 /// The code of the signature.
368 /// <para>Since EFL 1.23.</para>
369 /// </summary>
150 public const char Code = 'g'; 370 public const char Code = 'g';
371 /// <summary>
372 /// The signature of the signature.
373 /// <para>Since EFL 1.23.</para>
374 /// </summary>
151 public const string Signature = "g"; 375 public const string Signature = "g";
152 } 376 }
153 377
378 /// <summary>
379 /// The type of a array.
380 /// <para>Since EFL 1.23.</para>
381 /// </summary>
154 public class ArrayType 382 public class ArrayType
155 { 383 {
384 /// <summary>
385 /// The code of the array.
386 /// <para>Since EFL 1.23.</para>
387 /// </summary>
156 public const char Code = 'a'; 388 public const char Code = 'a';
389 /// <summary>
390 /// The signature of the array.
391 /// <para>Since EFL 1.23.</para>
392 /// </summary>
157 public const string Signature = "a"; 393 public const string Signature = "a";
158 } 394 }
159 395
396 /// <summary>
397 /// The type of a struct.
398 /// <para>Since EFL 1.23.</para>
399 /// </summary>
160 public class StructType 400 public class StructType
161 { 401 {
402 /// <summary>
403 /// The code of the struct.
404 /// <para>Since EFL 1.23.</para>
405 /// </summary>
162 public const char Code = 'r'; 406 public const char Code = 'r';
407 /// <summary>
408 /// The signature of the struct.
409 /// <para>Since EFL 1.23.</para>
410 /// </summary>
163 public const string Signature = "r"; 411 public const string Signature = "r";
164 } 412 }
165 413
414 /// <summary>
415 /// The type of a variant.
416 /// <para>Since EFL 1.23.</para>
417 /// </summary>
166 public class VariantType 418 public class VariantType
167 { 419 {
420 /// <summary>
421 /// The code of the variant.
422 /// <para>Since EFL 1.23.</para>
423 /// </summary>
168 public const char Code = 'v'; 424 public const char Code = 'v';
425 /// <summary>
426 /// The signature of the variant.
427 /// <para>Since EFL 1.23.</para>
428 /// </summary>
169 public const string Signature = "v"; 429 public const string Signature = "v";
170 } 430 }
171 431
432 /// <summary>
433 /// The type of a dictionary.
434 /// <para>Since EFL 1.23.</para>
435 /// </summary>
172 public class DictEntryType 436 public class DictEntryType
173 { 437 {
438 /// <summary>
439 /// The code of the dictionary.
440 /// <para>Since EFL 1.23.</para>
441 /// </summary>
174 public const char Code = 'e'; 442 public const char Code = 'e';
443 /// <summary>
444 /// The signature of the dictionary.
445 /// <para>Since EFL 1.23.</para>
446 /// </summary>
175 public const string Signature = "e"; 447 public const string Signature = "e";
176 } 448 }
177 449
450 /// <summary>
451 /// The type of an unix file descriptor.
452 /// <para>Since EFL 1.23.</para>
453 /// </summary>
178 public class UnixFdType 454 public class UnixFdType
179 { 455 {
456 /// <summary>
457 /// The code of unix fd.
458 /// <para>Since EFL 1.23.</para>
459 /// </summary>
180 public const char Code = 'h'; 460 public const char Code = 'h';
461 /// <summary>
462 /// The signature of the unix fd.
463 /// <para>Since EFL 1.23.</para>
464 /// </summary>
181 public const string Signature = "h"; 465 public const string Signature = "h";
182 } 466 }
183 467
@@ -218,8 +502,17 @@ public static class Argument
218// public static readonly UnixFdType h = UnixFdT; 502// public static readonly UnixFdType h = UnixFdT;
219} 503}
220 504
505/// <summary>
506/// Arguments to a basic message eldbus.
507/// <para>Since EFL 1.23.</para>
508/// </summary>
221public abstract class BasicMessageArgument 509public abstract class BasicMessageArgument
222{ 510{
511 /// <summary>
512 /// Appends a message to eldbus.
513 /// <para>Since EFL 1.23.</para>
514 /// </summary>
515 /// <param name="msg">The message to be appended.</param>
223 public void AppendTo(eldbus.Message msg) 516 public void AppendTo(eldbus.Message msg)
224 { 517 {
225 if (!InternalAppendTo(msg)) 518 if (!InternalAppendTo(msg))
@@ -228,6 +521,11 @@ public abstract class BasicMessageArgument
228 } 521 }
229 } 522 }
230 523
524 /// <summary>
525 /// Appends a message to eldbus.
526 /// <para>Since EFL 1.23.</para>
527 /// </summary>
528 /// <param name="iter">The messages to append.</param>
231 public void AppendTo(eldbus.MessageIterator iter) 529 public void AppendTo(eldbus.MessageIterator iter)
232 { 530 {
233 if (!InternalAppendTo(iter)) 531 if (!InternalAppendTo(iter))
@@ -236,447 +534,786 @@ public abstract class BasicMessageArgument
236 } 534 }
237 } 535 }
238 536
537 /// <summary>
538 /// The code of the type.
539 /// <para>Since EFL 1.23.</para>
540 /// </summary>
239 public abstract char TypeCode {get;} 541 public abstract char TypeCode {get;}
542
543 /// <summary>
544 /// The signature of the type.
545 /// <para>Since EFL 1.23.</para>
546 /// </summary>
240 public abstract string Signature {get;} 547 public abstract string Signature {get;}
548
549 [EditorBrowsable(EditorBrowsableState.Never)]
241 protected abstract bool InternalAppendTo(eldbus.Message msg); 550 protected abstract bool InternalAppendTo(eldbus.Message msg);
551
552 [EditorBrowsable(EditorBrowsableState.Never)]
242 protected abstract bool InternalAppendTo(eldbus.MessageIterator iter); 553 protected abstract bool InternalAppendTo(eldbus.MessageIterator iter);
243 554
555 /// <summary>
556 /// Conversion operator of BasicMessageArgument from byte.
557 /// <para>Since EFL 1.23.</para>
558 /// </summary>
559 /// <param name="arg">The byte to be converted.</param>
244 public static implicit operator BasicMessageArgument(byte arg) 560 public static implicit operator BasicMessageArgument(byte arg)
245 { 561 {
246 return new ByteMessageArgument(arg); 562 return new ByteMessageArgument(arg);
247 } 563 }
248 564
565 /// <summary>
566 /// Conversion operator of BasicMessageArgument from bool.
567 /// <para>Since EFL 1.23.</para>
568 /// </summary>
569 /// <param name="arg">The bool to be converted.</param>
249 public static implicit operator BasicMessageArgument(bool arg) 570 public static implicit operator BasicMessageArgument(bool arg)
250 { 571 {
251 return new BoolMessageArgument(arg); 572 return new BoolMessageArgument(arg);
252 } 573 }
253 574
575 /// <summary>
576 /// Conversion operator of BasicMessageArgument from Int16.
577 /// <para>Since EFL 1.23.</para>
578 /// </summary>
579 /// <param name="arg">The int16 to be converted.</param>
254 public static implicit operator BasicMessageArgument(Int16 arg) 580 public static implicit operator BasicMessageArgument(Int16 arg)
255 { 581 {
256 return new Int16MessageArgument(arg); 582 return new Int16MessageArgument(arg);
257 } 583 }
258 584
585 /// <summary>
586 /// Conversion operator of BasicMessageArgument from unsigned int16.
587 /// <para>Since EFL 1.23.</para>
588 /// </summary>
589 /// <param name="arg">The unsigned int16 to be converted.</param>
259 public static implicit operator BasicMessageArgument(UInt16 arg) 590 public static implicit operator BasicMessageArgument(UInt16 arg)
260 { 591 {
261 return new UInt16MessageArgument(arg); 592 return new UInt16MessageArgument(arg);
262 } 593 }
263 594
595 /// <summary>
596 /// Conversion operator of BasicMessageArgument from int32.
597 /// <para>Since EFL 1.23.</para>
598 /// </summary>
599 /// <param name="arg">The int32 to be converted.</param>
264 public static implicit operator BasicMessageArgument(Int32 arg) 600 public static implicit operator BasicMessageArgument(Int32 arg)
265 { 601 {
266 return new Int32MessageArgument(arg); 602 return new Int32MessageArgument(arg);
267 } 603 }
268 604
605 /// <summary>
606 /// Conversion operator of BasicMessageArgument from unsigned int32.
607 /// <para>Since EFL 1.23.</para>
608 /// </summary>
609 /// <param name="arg">The unsigned int32 to be converted.</param>
269 public static implicit operator BasicMessageArgument(UInt32 arg) 610 public static implicit operator BasicMessageArgument(UInt32 arg)
270 { 611 {
271 return new UInt32MessageArgument(arg); 612 return new UInt32MessageArgument(arg);
272 } 613 }
273 614
615 /// <summary>
616 /// Conversion operator of BasicMessageArgument from int64.
617 /// <para>Since EFL 1.23.</para>
618 /// </summary>
619 /// <param name="arg">The int64 to be converted.</param>
274 public static implicit operator BasicMessageArgument(Int64 arg) 620 public static implicit operator BasicMessageArgument(Int64 arg)
275 { 621 {
276 return new Int64MessageArgument(arg); 622 return new Int64MessageArgument(arg);
277 } 623 }
278 624
625 /// <summary>
626 /// Conversion operator of BasicMessageArgument from unsigned int64.
627 /// <para>Since EFL 1.23.</para>
628 /// </summary>
629 /// <param name="arg">The unsigned int64 to be converted.</param>
279 public static implicit operator BasicMessageArgument(UInt64 arg) 630 public static implicit operator BasicMessageArgument(UInt64 arg)
280 { 631 {
281 return new UInt64MessageArgument(arg); 632 return new UInt64MessageArgument(arg);
282 } 633 }
283 634
635 /// <summary>
636 /// Conversion operator of BasicMessageArgument from string.
637 /// <para>Since EFL 1.23.</para>
638 /// </summary>
639 /// <param name="arg">the string to be converted.</param>
284 public static implicit operator BasicMessageArgument(string arg) 640 public static implicit operator BasicMessageArgument(string arg)
285 { 641 {
286 return new StringMessageArgument(arg); 642 return new StringMessageArgument(arg);
287 } 643 }
288 644
645 /// <summary>
646 /// Conversion operator of BasicMessageArgument from signature.
647 /// <para>Since EFL 1.23.</para>
648 /// </summary>
649 /// <param name="arg">The signature to be converted.</param>
289 public static implicit operator BasicMessageArgument(SignatureString arg) 650 public static implicit operator BasicMessageArgument(SignatureString arg)
290 { 651 {
291 return new SignatureMessageArgument(arg); 652 return new SignatureMessageArgument(arg);
292 } 653 }
293 654
655 /// <summary>
656 /// Conversion operator of BasicMessageArgument from object path.
657 /// <para>Since EFL 1.23.</para>
658 /// </summary>
659 /// <param name="arg">The object path to be converted.</param>
294 public static implicit operator BasicMessageArgument(ObjectPath arg) 660 public static implicit operator BasicMessageArgument(ObjectPath arg)
295 { 661 {
296 return new ObjectPathMessageArgument(arg); 662 return new ObjectPathMessageArgument(arg);
297 } 663 }
298 664
665 /// <summary>
666 /// Conversion operator of BasicMessageArgument from unix fd.
667 /// <para>Since EFL 1.23.</para>
668 /// </summary>
669 /// <param name="arg">The unix fd to be converted.</param>
299 public static implicit operator BasicMessageArgument(UnixFd arg) 670 public static implicit operator BasicMessageArgument(UnixFd arg)
300 { 671 {
301 return new UnixFdMessageArgument(arg); 672 return new UnixFdMessageArgument(arg);
302 } 673 }
303} 674}
304 675
676/// <summary>
677/// Arguments to a byte message eldbus.
678/// <para>Since EFL 1.23.</para>
679/// </summary>
305public class ByteMessageArgument : BasicMessageArgument 680public class ByteMessageArgument : BasicMessageArgument
306{ 681{
307 private byte value; 682 private byte value;
308 683
684 /// <summary>
685 /// Constructor.
686 /// <para>Since EFL 1.23.</para>
687 /// </summary>
688 /// <param name="arg">The argument of the eldbus.</param>
309 public ByteMessageArgument(byte arg) 689 public ByteMessageArgument(byte arg)
310 { 690 {
311 value = arg; 691 value = arg;
312 } 692 }
313 693
694 /// <summary>
695 /// The code of the type.
696 /// <para>Since EFL 1.23.</para>
697 /// </summary>
314 public override char TypeCode 698 public override char TypeCode
315 { 699 {
316 get { return Argument.ByteType.Code; } 700 get { return Argument.ByteType.Code; }
317 } 701 }
318 702
703 /// <summary>
704 /// The signature of the type.
705 /// <para>Since EFL 1.23.</para>
706 /// </summary>
319 public override string Signature 707 public override string Signature
320 { 708 {
321 get { return Argument.ByteType.Signature; } 709 get { return Argument.ByteType.Signature; }
322 } 710 }
323 711
712 [EditorBrowsable(EditorBrowsableState.Never)]
324 protected override bool InternalAppendTo(eldbus.Message msg) 713 protected override bool InternalAppendTo(eldbus.Message msg)
325 { 714 {
326 return eldbus_message_arguments_append(msg.Handle, Signature, value); 715 return eldbus_message_arguments_append(msg.Handle, Signature, value);
327 } 716 }
328 717
718 [EditorBrowsable(EditorBrowsableState.Never)]
329 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 719 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
330 { 720 {
331 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 721 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
332 } 722 }
333} 723}
334 724
725/// <summary>
726/// Arguments to a bool message eldbus.
727/// <para>Since EFL 1.23.</para>
728/// </summary>
335public class BoolMessageArgument : BasicMessageArgument 729public class BoolMessageArgument : BasicMessageArgument
336{ 730{
337 private Int32 value; 731 private Int32 value;
338 732
733 /// <summary>
734 /// Constructor.
735 /// <para>Since EFL 1.23.</para>
736 /// </summary>
737 /// <param name="arg">The arguments of the eldbus.</param>
339 public BoolMessageArgument(bool arg) 738 public BoolMessageArgument(bool arg)
340 { 739 {
341 value = Convert.ToInt32(arg); 740 value = Convert.ToInt32(arg);
342 } 741 }
343 742
743 /// <summary>
744 /// The code of the type.
745 /// <para>Since EFL 1.23.</para>
746 /// </summary>
344 public override char TypeCode 747 public override char TypeCode
345 { 748 {
346 get { return Argument.BooleanType.Code; } 749 get { return Argument.BooleanType.Code; }
347 } 750 }
348 751
752 /// <summary>
753 /// The signature of the type.
754 /// <para>Since EFL 1.23.</para>
755 /// </summary>
349 public override string Signature 756 public override string Signature
350 { 757 {
351 get { return Argument.ByteType.Signature; } 758 get { return Argument.ByteType.Signature; }
352 } 759 }
353 760
761 [EditorBrowsable(EditorBrowsableState.Never)]
354 protected override bool InternalAppendTo(eldbus.Message msg) 762 protected override bool InternalAppendTo(eldbus.Message msg)
355 { 763 {
356 return eldbus_message_arguments_append(msg.Handle, Signature, value); 764 return eldbus_message_arguments_append(msg.Handle, Signature, value);
357 } 765 }
358 766
767 [EditorBrowsable(EditorBrowsableState.Never)]
359 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 768 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
360 { 769 {
361 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 770 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
362 } 771 }
363} 772}
364 773
774/// <summary>
775/// Arguments to an int16 message eldbus.
776/// <para>Since EFL 1.23.</para>
777/// </summary>
365public class Int16MessageArgument : BasicMessageArgument 778public class Int16MessageArgument : BasicMessageArgument
366{ 779{
367 private Int16 value; 780 private Int16 value;
368 781
782 /// <summary>
783 /// Constructor.
784 /// <para>Since EFL 1.23.</para>
785 /// </summary>
786 /// <param name="arg">The arguments of the eldbus.</param>
369 public Int16MessageArgument(Int16 arg) 787 public Int16MessageArgument(Int16 arg)
370 { 788 {
371 value = arg; 789 value = arg;
372 } 790 }
373 791
792 /// <summary>
793 /// The code of the type.
794 /// <para>Since EFL 1.23.</para>
795 /// </summary>
374 public override char TypeCode 796 public override char TypeCode
375 { 797 {
376 get { return Argument.Int16Type.Code; } 798 get { return Argument.Int16Type.Code; }
377 } 799 }
378 800
801 /// <summary>
802 /// The signature of the type.
803 /// <para>Since EFL 1.23.</para>
804 /// </summary>
379 public override string Signature 805 public override string Signature
380 { 806 {
381 get { return Argument.ByteType.Signature; } 807 get { return Argument.ByteType.Signature; }
382 } 808 }
383 809
810 [EditorBrowsable(EditorBrowsableState.Never)]
384 protected override bool InternalAppendTo(eldbus.Message msg) 811 protected override bool InternalAppendTo(eldbus.Message msg)
385 { 812 {
386 return eldbus_message_arguments_append(msg.Handle, Signature, value); 813 return eldbus_message_arguments_append(msg.Handle, Signature, value);
387 } 814 }
388 815
816 [EditorBrowsable(EditorBrowsableState.Never)]
389 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 817 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
390 { 818 {
391 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 819 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
392 } 820 }
393} 821}
394 822
823/// <summary>
824/// Arguments to an unsigned int16 message eldbus.
825/// <para>Since EFL 1.23.</para>
826/// </summary>
395public class UInt16MessageArgument : BasicMessageArgument 827public class UInt16MessageArgument : BasicMessageArgument
396{ 828{
397 private UInt16 value; 829 private UInt16 value;
398 830
831 /// <summary>
832 /// Constructor.
833 /// <para>Since EFL 1.23.</para>
834 /// </summary>
835 /// <param name="arg">the arguments of the eldbus.</param>
399 public UInt16MessageArgument(UInt16 arg) 836 public UInt16MessageArgument(UInt16 arg)
400 { 837 {
401 value = arg; 838 value = arg;
402 } 839 }
403 840
841 /// <summary>
842 /// The code of the type.
843 /// <para>Since EFL 1.23.</para>
844 /// </summary>
404 public override char TypeCode 845 public override char TypeCode
405 { 846 {
406 get { return Argument.UInt16Type.Code; } 847 get { return Argument.UInt16Type.Code; }
407 } 848 }
408 849
850 /// <summary>
851 /// The signature of the type.
852 /// <para>Since EFL 1.23.</para>
853 /// </summary>
409 public override string Signature 854 public override string Signature
410 { 855 {
411 get { return Argument.ByteType.Signature; } 856 get { return Argument.ByteType.Signature; }
412 } 857 }
413 858
859 [EditorBrowsable(EditorBrowsableState.Never)]
414 protected override bool InternalAppendTo(eldbus.Message msg) 860 protected override bool InternalAppendTo(eldbus.Message msg)
415 { 861 {
416 return eldbus_message_arguments_append(msg.Handle, Signature, value); 862 return eldbus_message_arguments_append(msg.Handle, Signature, value);
417 } 863 }
418 864
865 [EditorBrowsable(EditorBrowsableState.Never)]
419 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 866 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
420 { 867 {
421 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 868 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
422 } 869 }
423} 870}
424 871
872/// <summary>
873/// Arguments to an int32 message eldbus.
874/// <para>Since EFL 1.23.</para>
875/// </summary>
425public class Int32MessageArgument : BasicMessageArgument 876public class Int32MessageArgument : BasicMessageArgument
426{ 877{
427 private Int32 value; 878 private Int32 value;
428 879
880 /// <summary>
881 /// Constructor.
882 /// <para>Since EFL 1.23.</para>
883 /// </summary>
884 /// <param name="arg">The arguments of the eldbus.</param>
429 public Int32MessageArgument(Int32 arg) 885 public Int32MessageArgument(Int32 arg)
430 { 886 {
431 value = arg; 887 value = arg;
432 } 888 }
433 889
890 /// <summary>
891 /// The code of the type.
892 /// <para>Since EFL 1.23.</para>
893 /// </summary>
434 public override char TypeCode 894 public override char TypeCode
435 { 895 {
436 get { return Argument.Int32Type.Code; } 896 get { return Argument.Int32Type.Code; }
437 } 897 }
438 898
899 /// <summary>
900 /// The signature of the type.
901 /// <para>Since EFL 1.23.</para>
902 /// </summary>
439 public override string Signature 903 public override string Signature
440 { 904 {
441 get { return Argument.ByteType.Signature; } 905 get { return Argument.ByteType.Signature; }
442 } 906 }
443 907
908 [EditorBrowsable(EditorBrowsableState.Never)]
444 protected override bool InternalAppendTo(eldbus.Message msg) 909 protected override bool InternalAppendTo(eldbus.Message msg)
445 { 910 {
446 return eldbus_message_arguments_append(msg.Handle, Signature, value); 911 return eldbus_message_arguments_append(msg.Handle, Signature, value);
447 } 912 }
448 913
914 [EditorBrowsable(EditorBrowsableState.Never)]
449 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 915 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
450 { 916 {
451 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 917 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
452 } 918 }
453} 919}
454 920
921/// <summary>
922/// Arguments to an unsigned int32 message eldbus.
923/// <para>Since EFL 1.23.</para>
924/// </summary>
455public class UInt32MessageArgument : BasicMessageArgument 925public class UInt32MessageArgument : BasicMessageArgument
456{ 926{
457 private UInt32 value; 927 private UInt32 value;
458 928
929 /// <summary>
930 /// Constructor.
931 /// <para>Since EFL 1.23.</para>
932 /// </summary>
933 /// <param name="arg">The arguments of the unsigned type.</param>
459 public UInt32MessageArgument(UInt32 arg) 934 public UInt32MessageArgument(UInt32 arg)
460 { 935 {
461 value = arg; 936 value = arg;
462 } 937 }
463 938
939 /// <summary>
940 /// The code of the type.
941 /// <para>Since EFL 1.23.</para>
942 /// </summary>
464 public override char TypeCode 943 public override char TypeCode
465 { 944 {
466 get { return Argument.UInt32Type.Code; } 945 get { return Argument.UInt32Type.Code; }
467 } 946 }
468 947
948 /// <summary>
949 /// The signature of the type.
950 /// <para>Since EFL 1.23.</para>
951 /// </summary>
469 public override string Signature 952 public override string Signature
470 { 953 {
471 get { return Argument.ByteType.Signature; } 954 get { return Argument.ByteType.Signature; }
472 } 955 }
473 956
957 [EditorBrowsable(EditorBrowsableState.Never)]
474 protected override bool InternalAppendTo(eldbus.Message msg) 958 protected override bool InternalAppendTo(eldbus.Message msg)
475 { 959 {
476 return eldbus_message_arguments_append(msg.Handle, Signature, value); 960 return eldbus_message_arguments_append(msg.Handle, Signature, value);
477 } 961 }
478 962
963 [EditorBrowsable(EditorBrowsableState.Never)]
479 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 964 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
480 { 965 {
481 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 966 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
482 } 967 }
483} 968}
484 969
970/// <summary>
971/// Arguments to an int64 message eldbus.
972/// <para>Since EFL 1.23.</para>
973/// </summary>
485public class Int64MessageArgument : BasicMessageArgument 974public class Int64MessageArgument : BasicMessageArgument
486{ 975{
487 private Int64 value; 976 private Int64 value;
488 977
978 /// <summary>
979 /// Constructor.
980 /// <para>Since EFL 1.23.</para>
981 /// </summary>
982 /// <param name="arg">The arguments of the eldbus.</param>
489 public Int64MessageArgument(Int64 arg) 983 public Int64MessageArgument(Int64 arg)
490 { 984 {
491 value = arg; 985 value = arg;
492 } 986 }
493 987
988 /// <summary>
989 /// The code of the type.
990 /// <para>Since EFL 1.23.</para>
991 /// </summary>
494 public override char TypeCode 992 public override char TypeCode
495 { 993 {
496 get { return Argument.Int64Type.Code; } 994 get { return Argument.Int64Type.Code; }
497 } 995 }
498 996
997 /// <summary>
998 /// The signature of the type.
999 /// <para>Since EFL 1.23.</para>
1000 /// </summary>
499 public override string Signature 1001 public override string Signature
500 { 1002 {
501 get { return Argument.ByteType.Signature; } 1003 get { return Argument.ByteType.Signature; }
502 } 1004 }
503 1005
1006 [EditorBrowsable(EditorBrowsableState.Never)]
504 protected override bool InternalAppendTo(eldbus.Message msg) 1007 protected override bool InternalAppendTo(eldbus.Message msg)
505 { 1008 {
506 return eldbus_message_arguments_append(msg.Handle, Signature, value); 1009 return eldbus_message_arguments_append(msg.Handle, Signature, value);
507 } 1010 }
508 1011
1012 [EditorBrowsable(EditorBrowsableState.Never)]
509 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 1013 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
510 { 1014 {
511 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 1015 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
512 } 1016 }
513} 1017}
514 1018
1019/// <summary>
1020/// Arguments to an unsigned int64 message eldbus.
1021/// <para>Since EFL 1.23.</para>
1022/// </summary>
515public class UInt64MessageArgument : BasicMessageArgument 1023public class UInt64MessageArgument : BasicMessageArgument
516{ 1024{
517 private UInt64 value; 1025 private UInt64 value;
518 1026
1027 /// <summary>
1028 /// Constructor.
1029 /// <para>Since EFL 1.23.</para>
1030 /// </summary>
1031 /// <param name="arg">The arguments of the eldbus.</param>
519 public UInt64MessageArgument(UInt64 arg) 1032 public UInt64MessageArgument(UInt64 arg)
520 { 1033 {
521 value = arg; 1034 value = arg;
522 } 1035 }
523 1036
1037 /// <summary>
1038 /// The code of the type.
1039 /// <para>Since EFL 1.23.</para>
1040 /// </summary>
524 public override char TypeCode 1041 public override char TypeCode
525 { 1042 {
526 get { return Argument.UInt64Type.Code; } 1043 get { return Argument.UInt64Type.Code; }
527 } 1044 }
528 1045
1046 /// <summary>
1047 /// The signature of the type.
1048 /// <para>Since EFL 1.23.</para>
1049 /// </summary>
529 public override string Signature 1050 public override string Signature
530 { 1051 {
531 get { return Argument.ByteType.Signature; } 1052 get { return Argument.ByteType.Signature; }
532 } 1053 }
533 1054
1055 [EditorBrowsable(EditorBrowsableState.Never)]
534 protected override bool InternalAppendTo(eldbus.Message msg) 1056 protected override bool InternalAppendTo(eldbus.Message msg)
535 { 1057 {
536 return eldbus_message_arguments_append(msg.Handle, Signature, value); 1058 return eldbus_message_arguments_append(msg.Handle, Signature, value);
537 } 1059 }
538 1060
1061 [EditorBrowsable(EditorBrowsableState.Never)]
539 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 1062 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
540 { 1063 {
541 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 1064 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
542 } 1065 }
543} 1066}
544 1067
1068/// <summary>
1069/// Arguments to a double message eldbus.
1070/// <para>Since EFL 1.23.</para>
1071/// </summary>
545public class DoubleMessageArgument : BasicMessageArgument 1072public class DoubleMessageArgument : BasicMessageArgument
546{ 1073{
547 private double value; 1074 private double value;
548 1075
1076 /// <summary>
1077 /// Constructor.
1078 /// <para>Since EFL 1.23.</para>
1079 /// </summary>
1080 /// <param name="arg">The arguments of the eldbus.</param>
549 public DoubleMessageArgument(double arg) 1081 public DoubleMessageArgument(double arg)
550 { 1082 {
551 value = arg; 1083 value = arg;
552 } 1084 }
553 1085
1086 /// <summary>
1087 /// The code of the type.
1088 /// <para>Since EFL 1.23.</para>
1089 /// </summary>
554 public override char TypeCode 1090 public override char TypeCode
555 { 1091 {
556 get { return Argument.DoubleType.Code; } 1092 get { return Argument.DoubleType.Code; }
557 } 1093 }
558 1094
1095 /// <summary>
1096 /// The signature of the type.
1097 /// <para>Since EFL 1.23.</para>
1098 /// </summary>
559 public override string Signature 1099 public override string Signature
560 { 1100 {
561 get { return Argument.ByteType.Signature; } 1101 get { return Argument.ByteType.Signature; }
562 } 1102 }
563 1103
1104 [EditorBrowsable(EditorBrowsableState.Never)]
564 protected override bool InternalAppendTo(eldbus.Message msg) 1105 protected override bool InternalAppendTo(eldbus.Message msg)
565 { 1106 {
566 return eldbus_message_arguments_append(msg.Handle, Signature, value); 1107 return eldbus_message_arguments_append(msg.Handle, Signature, value);
567 } 1108 }
568 1109
1110 [EditorBrowsable(EditorBrowsableState.Never)]
569 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 1111 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
570 { 1112 {
571 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 1113 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
572 } 1114 }
573} 1115}
574 1116
1117/// <summary>
1118/// Arguments to a string like message eldbus.
1119/// <para>Since EFL 1.23.</para>
1120/// </summary>
575public abstract class StringLikeMessageArgument : BasicMessageArgument 1121public abstract class StringLikeMessageArgument : BasicMessageArgument
576{ 1122{
577 private string value; 1123 private string value;
578 1124
1125 /// <summary>
1126 /// Constructor.
1127 /// <para>Since EFL 1.23.</para>
1128 /// </summary>
1129 /// <param name="arg">The arguments of the eldbus.</param>
579 public StringLikeMessageArgument(string arg) 1130 public StringLikeMessageArgument(string arg)
580 { 1131 {
581 value = arg; 1132 value = arg;
582 } 1133 }
583 1134
1135 [EditorBrowsable(EditorBrowsableState.Never)]
584 protected override bool InternalAppendTo(eldbus.Message msg) 1136 protected override bool InternalAppendTo(eldbus.Message msg)
585 { 1137 {
586 return eldbus_message_arguments_append(msg.Handle, Signature, value); 1138 return eldbus_message_arguments_append(msg.Handle, Signature, value);
587 } 1139 }
588 1140
1141 [EditorBrowsable(EditorBrowsableState.Never)]
589 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 1142 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
590 { 1143 {
591 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 1144 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
592 } 1145 }
593} 1146}
594 1147
1148/// <summary>
1149/// Arguments to a string message eldbus.
1150/// <para>Since EFL 1.23.</para>
1151/// </summary>
595public class StringMessageArgument : StringLikeMessageArgument 1152public class StringMessageArgument : StringLikeMessageArgument
596{ 1153{
1154 /// <summary>
1155 /// Constructor.
1156 /// <para>Since EFL 1.23.</para>
1157 /// </summary>
1158 /// <param name="arg">The arguments of the eldbus.</param>
597 public StringMessageArgument(string arg) : base(arg) 1159 public StringMessageArgument(string arg) : base(arg)
598 { 1160 {
599 } 1161 }
600 1162
1163 /// <summary>
1164 /// The code of the type.
1165 /// <para>Since EFL 1.23.</para>
1166 /// </summary>
601 public override char TypeCode 1167 public override char TypeCode
602 { 1168 {
603 get { return Argument.StringType.Code; } 1169 get { return Argument.StringType.Code; }
604 } 1170 }
605 1171
1172 /// <summary>
1173 /// The signature of the type.
1174 /// <para>Since EFL 1.23.</para>
1175 /// </summary>
606 public override string Signature 1176 public override string Signature
607 { 1177 {
608 get { return Argument.ByteType.Signature; } 1178 get { return Argument.ByteType.Signature; }
609 } 1179 }
610} 1180}
611 1181
1182/// <summary>
1183/// Arguments to an object path message eldbus.
1184/// <para>Since EFL 1.23.</para>
1185/// </summary>
612public class ObjectPathMessageArgument : StringLikeMessageArgument 1186public class ObjectPathMessageArgument : StringLikeMessageArgument
613{ 1187{
1188 /// <summary>
1189 /// Constructor.
1190 /// <para>Since EFL 1.23.</para>
1191 /// </summary>
1192 /// <param name="arg"></param>
614 public ObjectPathMessageArgument(ObjectPath arg) : base(arg.value) 1193 public ObjectPathMessageArgument(ObjectPath arg) : base(arg.value)
615 { 1194 {
616 } 1195 }
617 1196
1197 /// <summary>
1198 /// The code of the type.
1199 /// <para>Since EFL 1.23.</para>
1200 /// </summary>
618 public override char TypeCode 1201 public override char TypeCode
619 { 1202 {
620 get { return Argument.ObjectPathType.Code; } 1203 get { return Argument.ObjectPathType.Code; }
621 } 1204 }
622 1205
1206 /// <summary>
1207 /// The signature of the type.
1208 /// <para>Since EFL 1.23.</para>
1209 /// </summary>
623 public override string Signature 1210 public override string Signature
624 { 1211 {
625 get { return Argument.ByteType.Signature; } 1212 get { return Argument.ByteType.Signature; }
626 } 1213 }
627} 1214}
628 1215
1216/// <summary>
1217/// Arguments to a signature message eldbus.
1218/// <para>Since EFL 1.23.</para>
1219/// </summary>
629public class SignatureMessageArgument : StringLikeMessageArgument 1220public class SignatureMessageArgument : StringLikeMessageArgument
630{ 1221{
1222 /// <summary>
1223 /// Constructor.
1224 /// <para>Since EFL 1.23.</para>
1225 /// </summary>
1226 /// <param name="arg">The arguments of the eldbus.</param>
631 public SignatureMessageArgument(SignatureString arg) : base(arg.value) 1227 public SignatureMessageArgument(SignatureString arg) : base(arg.value)
632 { 1228 {
633 } 1229 }
634 1230
1231 /// <summary>
1232 /// The code of the type.
1233 /// <para>Since EFL 1.23.</para>
1234 /// </summary>
635 public override char TypeCode 1235 public override char TypeCode
636 { 1236 {
637 get { return Argument.SignatureType.Code; } 1237 get { return Argument.SignatureType.Code; }
638 } 1238 }
639 1239
1240 /// <summary>
1241 /// The signature of the type.
1242 /// <para>Since EFL 1.23.</para>
1243 /// </summary>
640 public override string Signature 1244 public override string Signature
641 { 1245 {
642 get { return Argument.ByteType.Signature; } 1246 get { return Argument.ByteType.Signature; }
643 } 1247 }
644} 1248}
645 1249
1250/// <summary>
1251/// Arguments to an unixfd message eldbus.
1252/// <para>Since EFL 1.23.</para>
1253/// </summary>
646public class UnixFdMessageArgument : BasicMessageArgument 1254public class UnixFdMessageArgument : BasicMessageArgument
647{ 1255{
648 private Int32 value; 1256 private Int32 value;
649 1257
1258 /// <summary>
1259 /// Constructor.
1260 /// <para>Since EFL 1.23.</para>
1261 /// </summary>
1262 /// <param name="arg">The arguments of the eldbus.</param>
650 public UnixFdMessageArgument(UnixFd arg) 1263 public UnixFdMessageArgument(UnixFd arg)
651 { 1264 {
652 value = arg.value; 1265 value = arg.value;
653 } 1266 }
654 1267
1268 /// <summary>
1269 /// The code of the type.
1270 /// <para>Since EFL 1.23.</para>
1271 /// </summary>
655 public override char TypeCode 1272 public override char TypeCode
656 { 1273 {
657 get { return Argument.UnixFdType.Code; } 1274 get { return Argument.UnixFdType.Code; }
658 } 1275 }
659 1276
1277 /// <summary>
1278 /// The signature of the type.
1279 /// <para>Since EFL 1.23.</para>
1280 /// </summary>
660 public override string Signature 1281 public override string Signature
661 { 1282 {
662 get { return Argument.ByteType.Signature; } 1283 get { return Argument.ByteType.Signature; }
663 } 1284 }
664 1285
1286 [EditorBrowsable(EditorBrowsableState.Never)]
665 protected override bool InternalAppendTo(eldbus.Message msg) 1287 protected override bool InternalAppendTo(eldbus.Message msg)
666 { 1288 {
667 return eldbus_message_arguments_append(msg.Handle, Signature, value); 1289 return eldbus_message_arguments_append(msg.Handle, Signature, value);
668 } 1290 }
669 1291
1292 [EditorBrowsable(EditorBrowsableState.Never)]
670 protected override bool InternalAppendTo(eldbus.MessageIterator iter) 1293 protected override bool InternalAppendTo(eldbus.MessageIterator iter)
671 { 1294 {
672 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value); 1295 return eldbus_message_iter_basic_append(iter.Handle, TypeCode, value);
673 } 1296 }
674} 1297}
675 1298
1299/// <summary>
1300/// Function type to delegate a message.
1301/// <para>Since EFL 1.23.</para>
1302/// </summary>
1303/// <param name="msg">The message.</param>
1304/// <param name="pending"></param>
676public delegate void MessageDelegate(eldbus.Message msg, eldbus.Pending pending); 1305public delegate void MessageDelegate(eldbus.Message msg, eldbus.Pending pending);
677 1306
1307/// <summary>
1308/// Commons for eldbus.
1309/// <para>Since EFL 1.23.</para>
1310/// </summary>
678public static class Common 1311public static class Common
679{ 1312{
1313 /// <summary>
1314 /// Register the NullError.
1315 /// <para>Since EFL 1.23.</para>
1316 /// </summary>
680 public static void RaiseNullHandle() 1317 public static void RaiseNullHandle()
681 { 1318 {
682 if (NullHandleError == 0) 1319 if (NullHandleError == 0)
@@ -687,13 +1324,28 @@ public static class Common
687 Eina.Error.Raise(NullHandleError); 1324 Eina.Error.Raise(NullHandleError);
688 } 1325 }
689 1326
1327 /// <summary>
1328 /// Instance for a EldBus_Message_Cb.
1329 /// <para>Since EFL 1.23.</para>
1330 /// </summary>
1331 /// <param name="data">The data to the eldbus.</param>
1332 /// <param name="msg">The message to eldbus.</param>
1333 /// <param name="pending"></param>
690 public delegate void Eldbus_Message_Cb(IntPtr data, IntPtr msg, IntPtr pending); 1334 public delegate void Eldbus_Message_Cb(IntPtr data, IntPtr msg, IntPtr pending);
691 1335
1336 /// <summary>
1337 /// Get a wrapper for the message instance.
1338 /// <para>Since EFL 1.23.</para>
1339 /// </summary>
692 public static IntPtr GetMessageCbWrapperPtr() 1340 public static IntPtr GetMessageCbWrapperPtr()
693 { 1341 {
694 return Marshal.GetFunctionPointerForDelegate(GetMessageCbWrapper()); 1342 return Marshal.GetFunctionPointerForDelegate(GetMessageCbWrapper());
695 } 1343 }
696 1344
1345 /// <summary>
1346 /// Gets the message wrapper.
1347 /// <para>Since EFL 1.23.</para>
1348 /// </summary>
697 public static Eldbus_Message_Cb GetMessageCbWrapper() 1349 public static Eldbus_Message_Cb GetMessageCbWrapper()
698 { 1350 {
699 if (message_cb_wrapper == null) 1351 if (message_cb_wrapper == null)
@@ -704,6 +1356,13 @@ public static class Common
704 return message_cb_wrapper; 1356 return message_cb_wrapper;
705 } 1357 }
706 1358
1359 /// <summary>
1360 /// Wraps the data to a message.
1361 /// <para>Since EFL 1.23.</para>
1362 /// </summary>
1363 /// <param name="data"></param>
1364 /// <param name="msg_hdl"></param>
1365 /// <param name="pending_hdl"></param>
707 public static void MessageCbWrapper(IntPtr data, IntPtr msg_hdl, IntPtr pending_hdl) 1366 public static void MessageCbWrapper(IntPtr data, IntPtr msg_hdl, IntPtr pending_hdl)
708 { 1367 {
709 MessageDelegate dlgt = Marshal.GetDelegateForFunctionPointer(data, typeof(MessageDelegate)) as MessageDelegate; 1368 MessageDelegate dlgt = Marshal.GetDelegateForFunctionPointer(data, typeof(MessageDelegate)) as MessageDelegate;