cpp_core 0.6.0

Utilities for interoperability with C++
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

//! Comparison operator traits
//!
//! C++'s comparison operators have different semantics from Rust's `PartialOrd` and `Ord` traits.
//! If all the operators (`Lt`, `Le`, `Gt`, `Ge`) are implemented for a type, the pointer types
//! (`CppBox`, `Ptr`, `Ref`) automatically implement `PartialOrd`.

/// Represents C++'s `operator<`.
pub trait Lt<Rhs: ?Sized = Self> {
    /// This method tests less than (for `self` and `other`) and is used by the `<` operator.
    ///
    /// # Safety
    ///
    /// The caller must make sure `self` and `other` contain valid pointers. This function
    /// may invoke arbitrary foreign code, so no safety guarantees can be made.
    unsafe fn lt(&self, other: &Rhs) -> bool;
}

/// Represents C++'s `operator<=`.
pub trait Le<Rhs: ?Sized = Self> {
    /// This method tests less than or equal to (for `self` and `other`) and is used by the `<=`
    ///
    /// # Safety
    ///
    /// The caller must make sure `self` and `other` contain valid pointers. This function
    /// may invoke arbitrary foreign code, so no safety guarantees can be made.
    unsafe fn le(&self, other: &Rhs) -> bool;
}

/// Represents C++'s `operator>`.
pub trait Gt<Rhs: ?Sized = Self> {
    /// This method tests greater than (for `self` and `other`) and is used by the `>` operator.
    ///
    /// # Safety
    ///
    /// The caller must make sure `self` and `other` contain valid pointers. This function
    /// may invoke arbitrary foreign code, so no safety guarantees can be made.
    unsafe fn gt(&self, other: &Rhs) -> bool;
}

/// Represents C++'s `operator>=`.
pub trait Ge<Rhs: ?Sized = Self> {
    /// This method tests greater than or equal to (for `self` and `other`) and is used by the `>=`
    /// operator.
    ///
    /// # Safety
    ///
    /// The caller must make sure `self` and `other` contain valid pointers. This function
    /// may invoke arbitrary foreign code, so no safety guarantees can be made.
    unsafe fn ge(&self, other: &Rhs) -> bool;
}