cobia/cape_value.rs
1use std::fmt;
2use crate::C;
3use crate::*;
4
5/// CapeValueIn wraps a reference to an ICapeValue interface pointer.
6///
7/// Given a reference to an ICapeValue interface pointer, this allows getting,
8/// but not setting, the value.
9///
10/// This interface is typically used as arguments to rust methods
11/// on traits that are generated from CAPE-OPEN interfaces that have
12/// ICapeValue input arguments.
13///
14/// This class takes a reference to the interface pointer.
15///
16/// A NULL pointer is treated as an empty value.
17///
18/// # Examples
19///
20/// ```
21/// use cobia::*;
22///
23/// fn test_content(v: &CapeValueIn) {
24/// assert_eq!(v.get_string().unwrap(), "my value".to_string());
25/// }
26///
27/// let val = cobia::CapeValueImpl::from_string("my value".into());
28/// test_content(&CapeValueInFromProvider::from(&val).as_cape_value_in())
29/// ```
30
31pub struct CapeValueIn<'a> {
32 interface: &'a *mut C::ICapeValue,
33}
34
35impl<'a> CapeValueIn<'a> {
36
37 /// Create v new CapeValueIn from an ICapeValue interface pointer.
38 ///
39 /// # Arguments
40 ///
41 /// * `interface` - A pointer to an ICapeValue interface
42 ///
43 /// # Examples
44 ///
45 /// ```
46 /// use cobia::*;
47 /// use cobia::prelude::*;
48 /// let val = cobia::CapeValueImpl::from_integer(-8);
49 /// let i_cape_value=val.as_cape_value_in();
50 /// let mut i_cape_value_ptr=(&i_cape_value as *const C::ICapeValue).cast_mut(); //normally a pointer to the interface is received
51 /// let v = cobia::CapeValueIn::new(&mut i_cape_value_ptr); //CapeValueIn from *mut C::ICapeValue
52 /// assert_eq!(v.get_integer().unwrap(), -8);
53 /// ```
54
55 pub fn new(interface: &'a *mut C::ICapeValue) -> Self {
56 Self {
57 interface,
58 }
59 }
60
61 /// Get the value type
62 ///
63 /// # Examples
64 ///
65 /// ```
66 /// use cobia::*;
67 ///
68 /// fn test_type(v: &CapeValueIn) {
69 /// assert_eq!(v.get_type().unwrap(), cobia::CapeValueType::String);
70 /// }
71 ///
72 /// let val = cobia::CapeValueImpl::from_string("hydrogen".to_string());
73 /// test_type(&CapeValueInFromProvider::from(&val).as_cape_value_in())
74 /// ```
75
76 pub fn get_type(&self) -> Result<CapeValueType,COBIAError> {
77 if self.interface.is_null() {
78 return Ok(CapeValueType::Empty);
79 }
80 let tp= unsafe {(*(**self.interface).vTbl).getValueType.unwrap()((**self.interface).me)};
81 match CapeValueType::from(tp as i32) {
82 Some(v) => Ok(v),
83 None => Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
84 }
85 }
86
87 /// Get the value as a string
88 ///
89 /// Get the value as a string. If the value is not a string, an error is returned.
90 ///
91 /// # Examples
92 ///
93 /// ```
94 /// use cobia::*;
95 ///
96 /// fn test_string(v: &CapeValueIn) {
97 /// assert_eq!(v.get_string().unwrap(), "hydrogen".to_string());
98 /// }
99 ///
100 /// let val = cobia::CapeValueImpl::from_string("hydrogen".to_string());
101 /// test_string(&CapeValueInFromProvider::from(&val).as_cape_value_in())
102 /// ```
103
104 pub fn get_string(&self) -> Result<String,COBIAError> {
105 if self.interface.is_null() {
106 return Err(COBIAError::Code(COBIAERR_NOSUCHITEM));
107 }
108 let mut data: *const C::CapeCharacter = std::ptr::null();
109 let mut size: C::CapeSize = 0;
110 let res= unsafe {(*(**self.interface).vTbl).getStringValue.unwrap()((**self.interface).me,&mut data,&mut size)};
111 if res==COBIAERR_NOERROR {
112 Ok(unsafe {CapeStringImpl::from_raw_data(data,size)}.as_string())
113 } else {
114 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
115 }
116 }
117
118 /// Get the value as an integer
119 ///
120 /// Get the value as an integer. If the value is not an integer, an error is returned.
121 ///
122 /// # Examples
123 ///
124 /// ```
125 /// use cobia::*;
126 ///
127 /// fn test_integer(v: &CapeValueIn) {
128 /// assert_eq!(v.get_integer().unwrap(), 8);
129 /// }
130 ///
131 /// let val = cobia::CapeValueImpl::from_integer(8);
132 /// test_integer(&CapeValueInFromProvider::from(&val).as_cape_value_in())
133 /// ```
134
135 pub fn get_integer(&self) -> Result<i32,COBIAError> {
136 if self.interface.is_null() {
137 return Err(COBIAError::Code(COBIAERR_NOSUCHITEM));
138 }
139 let mut value: CapeInteger = 0;
140 let res= unsafe {(*(**self.interface).vTbl).getIntegerValue.unwrap()((**self.interface).me,&mut value)};
141 if res==COBIAERR_NOERROR {
142 Ok(value)
143 } else {
144 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
145 }
146 }
147
148 /// Get the value as a boolean
149 ///
150 /// Get the value as a boolean. If the value is not a boolean, an error is returned.
151 ///
152 /// # Examples
153 ///
154 /// ```
155 /// use cobia::*;
156 ///
157 /// fn test_boolean(v: &CapeValueIn) {
158 /// assert_eq!(v.get_boolean().unwrap(), true);
159 /// }
160 ///
161 /// let val = cobia::CapeValueImpl::from_boolean(true);
162 /// test_boolean(&CapeValueInFromProvider::from(&val).as_cape_value_in())
163 /// ```
164
165 pub fn get_boolean(&self) -> Result<bool,COBIAError> {
166 if self.interface.is_null() {
167 return Err(COBIAError::Code(COBIAERR_NOSUCHITEM));
168 }
169 let mut value: CapeBoolean = 0;
170 let res= unsafe {(*(**self.interface).vTbl).getBooleanValue.unwrap()((**self.interface).me,&mut value)};
171 if res==COBIAERR_NOERROR {
172 Ok(value!=0)
173 } else {
174 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
175 }
176 }
177
178 /// Get the value as a real
179 ///
180 /// Get the value as a real. If the value is not a real, an error is returned.
181 ///
182 /// # Examples
183 ///
184 /// ```
185 /// use cobia::*;
186 ///
187 /// fn test_real(v: &CapeValueIn) {
188 /// assert_eq!(v.get_real().unwrap(), 2.01568);
189 /// }
190 ///
191 /// let val = cobia::CapeValueImpl::from_real(2.01568);
192 /// test_real(&CapeValueInFromProvider::from(&val).as_cape_value_in())
193 /// ```
194
195 pub fn get_real(&self) -> Result<f64,COBIAError> {
196 if self.interface.is_null() {
197 return Err(COBIAError::Code(COBIAERR_NOSUCHITEM));
198 }
199 let mut value: CapeReal = 0.0;
200 let res= unsafe {(*(**self.interface).vTbl).getRealValue.unwrap()((**self.interface).me,&mut value)};
201 if res==COBIAERR_NOERROR {
202 Ok(value)
203 } else {
204 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
205 }
206 }
207
208}
209
210impl<'a> fmt::Display for CapeValueIn<'a> {
211
212 /// Display the content of the value
213 ///
214 /// # Examples
215 ///
216 /// ```
217 /// use cobia::*;
218 ///
219 /// fn test_format(v: &CapeValueIn) {
220 /// assert_eq!(format!("{}", v), "\"1333-74-0\"");
221 /// }
222 ///
223 /// let val = cobia::CapeValueImpl::from_string("1333-74-0".into());
224 /// test_format(&CapeValueInFromProvider::from(&val).as_cape_value_in())
225 /// ```
226
227 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
228 match self.get_type() {
229 Ok(CapeValueType::String) => {
230 match self.get_string() {
231 Ok(s) => write!(f, "\"{}\"",s),
232 _ => write!(f, "<invalid string>")
233 }
234 },
235 Ok(CapeValueType::Integer) => {
236 match self.get_integer() {
237 Ok(i) => write!(f, "{}",i),
238 _ => write!(f, "<invalid integer>")
239 }
240 },
241 Ok(CapeValueType::Boolean) => {
242 match self.get_boolean() {
243 Ok(b) => {
244 if b {
245 write!(f, "true")
246 } else {
247 write!(f, "false")
248 }
249 },
250 _ => write!(f, "<invalid boolean>")
251 }
252 },
253 Ok(CapeValueType::Real) => {
254 match self.get_real() {
255 Ok(r) => write!(f, "{}",r),
256 _ => write!(f, "<invalid real>")
257 }
258 },
259 Ok(CapeValueType::Empty) => write!(f, "<empty>"),
260 _ => write!(f, "<invalid value type>")
261 }
262 }
263}
264
265impl<'a> CapeValueProviderIn for CapeValueIn<'a> {
266 fn as_cape_value_in(&self) -> C::ICapeValue {
267 unsafe { **self.interface }
268 }
269}
270
271/// CapeValueOut wraps an ICapeValue interface pointer.
272///
273/// Given a reference to an ICapeValue interface pointer, this allows setting
274/// and getting the value.
275///
276/// A reference to a NULL pointer is not allowed here.
277///
278/// This interface is typically used as arguments to rust methods
279/// on traits that are generated from CAPE-OPEN interfaces that have
280/// ICapeValue ouput arguments.
281///
282/// This class takes a mutable reference to the interface pointer, as
283/// it should be the only class that is in use at a time to change the
284/// data behind the interface (as the data pointer is cached)
285///
286/// # Examples
287///
288/// ```
289/// use cobia::*;
290///
291/// fn set_value(v: &mut CapeValueOut) {
292/// v.set_string("my value").unwrap();
293/// }
294///
295/// let mut val = cobia::CapeValueImpl::new();
296/// set_value(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
297/// assert_eq!(val.value(), CapeValueContent::String("my value".into()));
298/// ```
299
300pub struct CapeValueOut<'a> {
301 interface: &'a mut *mut C::ICapeValue,
302}
303
304impl<'a> CapeValueOut<'a> {
305
306 /// Create v new CapeValueOut from an ICapeValue interface pointer.
307 ///
308 /// # Arguments
309 ///
310 /// * `interface` - A pointer to an ICapeValue interface
311 ///
312 /// # Examples
313 ///
314 /// ```
315 /// use cobia::*;
316 /// use cobia::prelude::*;
317 /// let mut val = cobia::CapeValueImpl::from_integer(-8);
318 /// let i_cape_value=val.as_cape_value_out();
319 /// let mut i_cape_value_ptr=(&i_cape_value as *const C::ICapeValue).cast_mut(); //normally a pointer to the interface is received
320 /// let v = cobia::CapeValueOut::new(&mut i_cape_value_ptr); //CapeValueOut from *mut C::ICapeValue
321 /// assert_eq!(v.get_integer().unwrap(), -8);
322 /// ```
323
324 pub fn new(interface: &'a mut *mut C::ICapeValue) -> Self {
325 Self {
326 interface,
327 }
328 }
329
330 /// Get the value type
331 ///
332 /// # Examples
333 ///
334 /// ```
335 /// use cobia::*;
336 ///
337 /// fn check_type(v: &mut CapeValueOut) {
338 /// assert_eq!(v.get_type().unwrap(), cobia::CapeValueType::String);
339 /// }
340 ///
341 /// let mut val = cobia::CapeValueImpl::from_string("hydrogen".into());
342 /// check_type(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
343 /// ```
344
345 pub fn get_type(&self) -> Result<CapeValueType,COBIAError> {
346 let tp= unsafe {(*(**self.interface).vTbl).getValueType.unwrap()((**self.interface).me)};
347 match CapeValueType::from(tp as i32) {
348 Some(v) => Ok(v),
349 None => Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
350 }
351 }
352
353 /// Get the value as a string
354 ///
355 /// Get the value as a string. If the value is not a string, an error is returned.
356 ///
357 /// # Examples
358 ///
359 /// ```
360 /// use cobia::*;
361 ///
362 /// fn check_string(v: &mut CapeValueOut) {
363 /// assert_eq!(v.get_string().unwrap(), "hydrogen".to_string());
364 /// }
365 ///
366 /// let mut val = cobia::CapeValueImpl::from_string("hydrogen".into());
367 /// check_string(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
368 /// ```
369
370 pub fn get_string(&self) -> Result<String,COBIAError> {
371 let mut data: *const C::CapeCharacter = std::ptr::null();
372 let mut size: C::CapeSize = 0;
373 let res= unsafe {(*(**self.interface).vTbl).getStringValue.unwrap()((**self.interface).me,&mut data,&mut size)};
374 if res==COBIAERR_NOERROR {
375 Ok(unsafe {CapeStringImpl::from_raw_data(data,size)}.as_string())
376 } else {
377 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
378 }
379 }
380
381 /// Get the value as an integer
382 ///
383 /// Get the value as an integer. If the value is not an integer, an error is returned.
384 ///
385 /// # Examples
386 ///
387 /// ```
388 /// use cobia::*;
389 ///
390 /// fn check_integer(v: &mut CapeValueOut) {
391 /// assert_eq!(v.get_integer().unwrap(), 8);
392 /// }
393 ///
394 /// let mut val = cobia::CapeValueImpl::from_integer(8);
395 /// check_integer(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
396 /// ```
397
398 pub fn get_integer(&self) -> Result<i32,COBIAError> {
399 let mut value: CapeInteger = 0;
400 let res= unsafe {(*(**self.interface).vTbl).getIntegerValue.unwrap()((**self.interface).me,&mut value)};
401 if res==COBIAERR_NOERROR {
402 Ok(value)
403 } else {
404 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
405 }
406 }
407
408 /// Get the value as a boolean
409 ///
410 /// Get the value as a boolean. If the value is not a boolean, an error is returned.
411 ///
412 /// # Examples
413 ///
414 /// ```
415 /// use cobia::*;
416 ///
417 /// fn check_boolean(v: &mut CapeValueOut) {
418 /// assert_eq!(v.get_boolean().unwrap(), true);
419 /// }
420 ///
421 /// let mut val = cobia::CapeValueImpl::from_boolean(true);
422 /// check_boolean(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
423 /// ```
424
425 pub fn get_boolean(&self) -> Result<bool,COBIAError> {
426 let mut value: CapeBoolean = 0;
427 let res= unsafe {(*(**self.interface).vTbl).getBooleanValue.unwrap()((**self.interface).me,&mut value)};
428 if res==COBIAERR_NOERROR {
429 Ok(value!=0)
430 } else {
431 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
432 }
433 }
434
435 /// Get the value as a real
436 ///
437 /// Get the value as a real. If the value is not a real, an error is returned.
438 ///
439 /// # Examples
440 ///
441 /// ```
442 /// use cobia::*;
443 ///
444 /// fn check_real(v: &mut CapeValueOut) {
445 /// assert_eq!(v.get_real().unwrap(), 2.01568);
446 /// }
447 ///
448 /// let mut val = cobia::CapeValueImpl::from_real(2.01568);
449 /// check_real(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
450 /// ```
451
452 pub fn get_real(&self) -> Result<f64,COBIAError> {
453 let mut value: CapeReal = 0.0;
454 let res= unsafe {(*(**self.interface).vTbl).getRealValue.unwrap()((**self.interface).me,&mut value)};
455 if res==COBIAERR_NOERROR {
456 Ok(value)
457 } else {
458 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
459 }
460 }
461
462 /// Set the value as a string
463 ///
464 /// # Arguments
465 ///
466 /// * `value` - The string value to set
467 ///
468 /// # Examples
469 ///
470 /// ```
471 /// use cobia::*;
472 ///
473 /// fn set_value(v: &mut CapeValueOut) {
474 /// v.set_string("my value").unwrap();
475 /// }
476 ///
477 /// let mut val = cobia::CapeValueImpl::new();
478 /// set_value(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
479 /// assert_eq!(val.value(), CapeValueContent::String("my value".into()));
480 /// ```
481
482 pub fn set_string<T: AsRef<str>>(&self, value: T) -> Result<(),COBIAError> {
483 let val = CapeStringImpl::from_string(value);
484 let (ptr, sz) = val.as_capechar_const_with_length();
485 let res= unsafe {(*(**self.interface).vTbl).setStringValue.unwrap()((**self.interface).me,ptr,sz)};
486 if res==COBIAERR_NOERROR {
487 Ok(())
488 } else {
489 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
490 }
491 }
492
493 /// Set the value as an integer
494 ///
495 /// # Arguments
496 ///
497 /// * `value` - The integer value to set
498 ///
499 /// # Examples
500 ///
501 /// ```
502 /// use cobia::*;
503 ///
504 /// fn set_value(v: &mut CapeValueOut) {
505 /// v.set_integer(8).unwrap();
506 /// }
507 ///
508 /// let mut val = cobia::CapeValueImpl::new();
509 /// set_value(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
510 /// assert_eq!(val.value(), CapeValueContent::Integer(8));
511 /// ```
512
513 pub fn set_integer(&self, value: CapeInteger) -> Result<(),COBIAError> {
514 let res= unsafe {(*(**self.interface).vTbl).setIntegerValue.unwrap()((**self.interface).me,value)};
515 if res==COBIAERR_NOERROR {
516 Ok(())
517 } else {
518 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
519 }
520 }
521
522 /// Set the value as a boolean
523 ///
524 /// # Arguments
525 ///
526 /// * `value` - The boolean value to set
527 ///
528 /// # Examples
529 ///
530 /// ```
531 /// use cobia::*;
532 ///
533 /// fn set_value(v: &mut CapeValueOut) {
534 /// v.set_boolean(true).unwrap()
535 /// }
536 ///
537 /// let mut val = cobia::CapeValueImpl::new();
538 /// set_value(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
539 /// assert_eq!(val.value(), CapeValueContent::Boolean(true));
540 /// ```
541
542 pub fn set_boolean(&self, value: bool) -> Result<(),COBIAError> {
543 let res= unsafe {(*(**self.interface).vTbl).setBooleanValue.unwrap()((**self.interface).me,value as CapeBoolean)};
544 if res==COBIAERR_NOERROR {
545 Ok(())
546 } else {
547 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
548 }
549 }
550
551 /// Set the value as a real
552 ///
553 /// # Arguments
554 ///
555 /// * `value` - The real value to set
556 ///
557 /// # Examples
558 ///
559 /// ```
560 /// use cobia::*;
561 ///
562 /// fn set_value(v: &mut CapeValueOut) {
563 /// v.set_real(2.01568).unwrap();
564 /// }
565 ///
566 /// let mut val = cobia::CapeValueImpl::new();
567 /// set_value(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
568 /// assert_eq!(val.value(), cobia::cape_value_impl::CapeValueContent::Real(2.01568));
569 /// ```
570
571 pub fn set_real(&self, value: CapeReal) -> Result<(),COBIAError> {
572 let res= unsafe {(*(**self.interface).vTbl).setRealValue.unwrap()((**self.interface).me,value)};
573 if res==COBIAERR_NOERROR {
574 Ok(())
575 } else {
576 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
577 }
578 }
579
580 /// Set the value to empty
581 ///
582 /// Set the value to empty. This is equivalent to setting the value to None in rust.
583 ///
584 /// # Examples
585 ///
586 /// ```
587 /// use cobia::*;
588 ///
589 /// fn set_value(v: &mut CapeValueOut) {
590 /// v.set_empty().unwrap();
591 /// }
592 ///
593 /// let mut val = cobia::CapeValueImpl::new();
594 /// set_value(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
595 /// assert_eq!(val.value(), cobia::cape_value_impl::CapeValueContent::Empty);
596 /// ```
597
598 pub fn set_empty(&self) -> Result<(),COBIAError> {
599 let res= unsafe {(*(**self.interface).vTbl).clear.unwrap()((**self.interface).me)};
600 if res==COBIAERR_NOERROR {
601 Ok(())
602 } else {
603 Err(COBIAError::Code(COBIAERR_NOSUCHITEM))
604 }
605 }
606
607 /// Set the value from a CapeValueProviderIn
608 ///
609 /// Set the value from a CapeValueProviderIn. This allows setting the value from any type that implements the CapeValueProviderIn trait.
610 ///
611 /// # Arguments
612 ///
613 /// * `value` - A reference to a type that implements the CapeValueProviderIn trait
614 ///
615 /// # Examples
616 ///
617 /// ```
618 /// use cobia::*;
619 /// let mut val = cobia::CapeValueImpl::new();
620 /// let val1 = cobia::CapeValueImpl::from_string("hydrogen".into());
621 /// CapeValueOutFromProvider::from(&mut val).as_cape_value_out().set(&val1);
622 /// assert_eq!(val.value(), cobia::cape_value_impl::CapeValueContent::String("hydrogen".into()));
623 /// ```
624
625 pub fn set<T: CapeValueProviderIn>(&mut self, value: &T) -> Result<(),COBIAError> {
626 let mut value_in_from_provider = CapeValueInFromProvider::from(value);
627 let value=value_in_from_provider.as_cape_value_in();
628 match value.get_type() {
629 Ok(CapeValueType::String) => self.set_string(value.get_string()?)?,
630 Ok(CapeValueType::Integer) => self.set_integer(value.get_integer()?)?,
631 Ok(CapeValueType::Boolean) => self.set_boolean(value.get_boolean()?)?,
632 Ok(CapeValueType::Real) => self.set_real(value.get_real()?)?,
633 Ok(CapeValueType::Empty) => self.set_empty()?,
634 _ => return Err(COBIAError::Code(COBIAERR_NOSUCHITEM)),
635 }
636 Ok(())
637 }
638
639}
640
641impl<'a> fmt::Display for CapeValueOut<'a> {
642
643 /// Display the content of the value
644 ///
645 /// # Examples
646 ///
647 /// ```
648 /// use cobia::*;
649 ///
650 /// fn test_format(v: &mut CapeValueOut) {
651 /// assert_eq!(format!("{}", v), "\"1333-74-0\"");
652 /// }
653 ///
654 /// let mut val = cobia::CapeValueImpl::from_string("1333-74-0".into());
655 /// test_format(&mut CapeValueOutFromProvider::from(&mut val).as_cape_value_out());
656 /// ```
657
658 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
659 match self.get_type() {
660 Ok(CapeValueType::String) => {
661 match self.get_string() {
662 Ok(s) => write!(f, "\"{}\"",s),
663 _ => write!(f, "<invalid string>")
664 }
665 },
666 Ok(CapeValueType::Integer) => {
667 match self.get_integer() {
668 Ok(i) => write!(f, "{}",i),
669 _ => write!(f, "<invalid integer>")
670 }
671 },
672 Ok(CapeValueType::Boolean) => {
673 match self.get_boolean() {
674 Ok(b) => {
675 if b {
676 write!(f, "true")
677 } else {
678 write!(f, "false")
679 }
680 },
681 _ => write!(f, "<invalid boolean>")
682 }
683 },
684 Ok(CapeValueType::Real) => {
685 match self.get_real() {
686 Ok(r) => write!(f, "{}",r),
687 _ => write!(f, "<invalid real>")
688 }
689 },
690 Ok(CapeValueType::Empty) => write!(f, "<empty>"),
691 _ => write!(f, "<invalid value type>")
692 }
693 }
694}
695
696impl<'a> CapeValueProviderOut for CapeValueOut<'a> {
697 fn as_cape_value_out(&mut self) -> C::ICapeValue {
698 unsafe { **self.interface }
699 }
700}