Struct ssbh_lib::RelPtr64

#[repr(transparent)]
pub struct RelPtr64<T: BinRead>(_);

A 64 bit file pointer relative to the start of the pointer type.

Implementations

impl<T: BinRead> RelPtr64<T>

pub fn new(value: T) -> Self

Creates a relative offset for value that is not null.

pub fn null() -> Self

Creates a relative offset for a null value.

Methods from Deref<Target = Option<T>>

#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"]

pub const fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

#[must_use = "if you intended to assert that this doesn't have a value, consider \ `.and_then(|_| panic!(\"`Option` had a value when expected `None`\"))` instead"]

pub const fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

#[must_use]

pub fn contains<U>(&self, x: &U) -> bool where
    U: PartialEq<T>, 

🔬 This is a nightly-only experimental API. (option_result_contains)

Returns true if the option is a Some value containing the given value.

Examples

#![feature(option_result_contains)]

let x: Option<u32> = Some(2);
assert_eq!(x.contains(&2), true);

let x: Option<u32> = Some(3);
assert_eq!(x.contains(&2), false);

let x: Option<u32> = None;
assert_eq!(x.contains(&2), false);

pub const fn as_ref(&self) -> Option<&T>

Converts from &Option<T> to Option<&T>.

Examples

Converts an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);

pub fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>

Converts from Pin<&Option<T>> to Option<Pin<&T>>.

pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>

Converts from Pin<&mut Option<T>> to Option<Pin<&mut T>>.

pub const fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

pub fn as_deref(&self) -> Option<&<T as Deref>::Target>

Converts from Option<T> (or &Option<T>) to Option<&T::Target>.

Leaves the original Option in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref.

Examples

let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));

let x: Option<String> = None;
assert_eq!(x.as_deref(), None);

Trait Implementations

impl<T: BinRead> BinRead for RelPtr64<T>

type Args = T::Args

The type of arguments needed to be supplied in order to read this type, usually a tuple.

fn read_options<R: Read + Seek>(
    reader: &mut R,
    options: &ReadOptions,
    args: Self::Args
) -> BinResult<Self>

Read the type from the reader

fn read<R>(reader: &mut R) -> Result<Self, Error> where
    R: Read + Seek, 

Read the type from the reader while assuming no arguments have been passed

fn read_args<R>(reader: &mut R, args: Self::Args) -> Result<Self, Error> where
    R: Read + Seek, 

Read the type from the reader using the specified arguments

fn after_parse<R>(
    &mut self,
    &mut R,
    &ReadOptions,
    Self::Args
) -> Result<(), Error> where
    R: Read + Seek, 

fn args_default() -> Option<Self::Args>

The default arguments to be used when using the read shortcut method. Override this for any type that optionally requries arguments

impl<T: Debug + BinRead> Debug for RelPtr64<T>

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

Formats the value using the given formatter.

impl<T: BinRead> Deref for RelPtr64<T>

type Target = Option<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, T: BinRead> Deserialize<'de> for RelPtr64<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: BinRead> Serialize for RelPtr64<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T: SsbhWrite + BinRead> SsbhWrite for RelPtr64<T>

fn write_ssbh<W: Write + Seek>(
    &self,
    writer: &mut W,
    data_ptr: &mut u64
) -> Result<()>

Writes the byte representation of self to writer and update data_ptr as needed to ensure the next relative offset is correctly calculated.

fn size_in_bytes(&self) -> u64

The offset in bytes between successive elements in an array of this type. This should include any alignment or padding. For most types, this is simply the value of std::mem::size_of.

fn alignment_in_bytes(&self) -> u64

The alignment of the relative_offset for types stored in a RelPtr64.