Struct CRange 

#[repr(C)]
pub struct CRange<T> {
    pub start: T,
    pub end: T,
}

A utility type to represent range. Note that the parametrized type T should have have CReprOf and AsRust trait implementated.

Example

use ffi_convert::{CReprOf, AsRust, CDrop, CRange};
use std::ops::Range;

#[derive(Clone, Debug, PartialEq)]
pub struct Foo {
    pub range: Range<i32>
}

#[derive(AsRust, CDrop, CReprOf, Debug, PartialEq)]
#[target_type(Foo)]
pub struct CFoo {
    pub range: CRange<i32>
}

let foo = Foo {
    range: Range {
        start: 20,
        end: 30,
    }
};

let c_foo = CFoo {
    range: CRange {
        start: 20,
        end: 30,
    }
};

let c_foo_converted = CFoo::c_repr_of(foo.clone()).unwrap();
assert_eq!(c_foo, c_foo_converted);

let foo_converted = c_foo.as_rust().unwrap();
assert_eq!(foo_converted, foo);

Fields

start: T

end: T

Trait Implementations

impl<U: AsRust<V>, V: PartialOrd + PartialEq> AsRust<Range<V>> for CRange<U>

fn as_rust(&self) -> Result<Range<V>, AsRustError>

impl<T> CDrop for CRange<T>

fn do_drop(&mut self) -> Result<(), CDropError>

impl<U: CReprOf<V> + CDrop, V: PartialOrd + PartialEq> CReprOf<Range<V>> for CRange<U>

fn c_repr_of(input: Range<V>) -> Result<Self, CReprOfError>

impl<T: Clone> Clone for CRange<T>

fn clone(&self) -> CRange<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for CRange<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Drop for CRange<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: PartialEq> PartialEq for CRange<T>

fn eq(&self, other: &CRange<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for CRange<T>

impl<T> StructuralPartialEq for CRange<T>