Struct Oop 

pub struct Oop(pub u64);

Tuple Fields

0: u64

Implementations

impl Oop

pub const ILLEGAL: Oop

pub const NIL: Oop

pub const FALSE: Oop

pub const TRUE: Oop

pub fn from_smallint(value: i64) -> Oop

pub fn from_bool(value: bool) -> Oop

pub fn from_char(value: char) -> Oop

pub fn raw(self) -> u64

Examples found in repository

examples/oop_values.rs (line 21)

fn main() -> gemstone_rs::Result<()> {
    let mut session = Session::login(Config::from_env()?)?;

    let seven = session.value_to_oop(&Value::SmallInt(7))?;
    let printed = session.perform_oop(seven, "printString", &[])?;
    println!(
        "small integer printString: {}",
        session.fetch_string(printed)?
    );

    let text = session.new_string("retained by gemstone-rs")?;
    {
        let handle = session.retain_oop(text)?;
        println!("retained string OOP: {}", handle.oop().raw());
        handle.release()?;
    }

    let symbol = session.new_symbol("GemStoneRsExampleSymbol")?;
    println!("new symbol OOP: {}", symbol.raw());
    Ok(())
}

examples/bridge_root_mapping.rs (line 57)

fn main() -> gemstone_rs::Result<()> {
    let mut session = Session::login(Config::from_env()?)?;

    let payload = BookingDraft {
        name: "Tariq".to_string(),
        amount: 100,
        currency: "GBP".to_string(),
    };

    let mut bridge_root = session.bridge_root()?;
    let payload_oop = bridge_root.put_mapped("MyTestDict", &payload)?;
    let stored = bridge_root.get_oop("MyTestDict")?;
    assert_eq!(payload_oop, stored);

    let loaded: BookingDraft = bridge_root.get_mapped("MyTestDict")?;
    assert_eq!(loaded, payload);

    println!("bridge root: {}", bridge_root.name());
    println!("bridge root OOP: {}", bridge_root.oop().raw());
    println!("MyTestDict OOP: {}", stored.raw());
    println!("loaded payload: {loaded:?}");

    bridge_root.commit()?;
    Ok(())
}

pub fn is_illegal(self) -> bool

pub fn is_nil(self) -> bool

pub fn is_boolean(self) -> bool

pub fn as_bool(self) -> Option<bool>

pub fn is_smallint(self) -> bool

pub fn as_smallint(self) -> Option<i64>

pub fn is_char(self) -> bool

pub fn as_char(self) -> Result<Option<char>, GciError>

Trait Implementations

impl BridgeFieldRead for Oop

fn read_bridge_oop( session: &mut Session, oop: Oop, _context: &BridgeFieldContext, ) -> Result<Self>

fn expected_type() -> &'static str

fn read_bridge_field( dictionary: &mut BridgeDictionary<'_>, key: &str, key_type: BridgeKeyType, ) -> Result<Self>

impl BridgeFieldWrite for Oop

fn to_bridge_field_value(&self) -> BridgeValue

impl Clone for Oop

fn clone(&self) -> Oop

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Oop

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

Formats the value using the given formatter.

impl From<Oop> for BridgeValue

fn from(value: Oop) -> Self

Converts to this type from the input type.

impl From<u64> for Oop

fn from(value: u64) -> Oop

Converts to this type from the input type.

impl Hash for Oop

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Oop

fn eq(&self, other: &Oop) -> 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 Copy for Oop

impl Eq for Oop

impl StructuralPartialEq for Oop