Struct memoverlay::Patch

pub struct Patch { /* private fields */ }

represents a memory patch. It is not allowed to create an empty patch

Example

use memoverlay::{SolidPatch, Patch};
assert!(Patch::new(10, &[0,1,2,3,4,5,6,7,8,9][..]).is_ok());
assert!(Patch::new(10, &[][..]).is_err());
assert!(Patch::new(10, &[0,1,2,3,4,5,6,7,8,9][3..3]).is_err());

Implementations

impl Patch

pub fn id(&self) -> u128

returns a unique id of this patch. Two patches have the same id if they have the same position and the same length. If two patches have the same offset, than the patch with the greater length has te greater id

pub fn begin(&self) -> u64

returns the offset of the first byte of this patch

pub fn end(&self) -> u64

returns the offset of the first byte after this patch

pub fn first_byte_offset(&self) -> u64

returns the offset of the first byte of this patch

pub fn last_byte_offset(&self) -> u64

returns the offset of the last byte of this patch, or None if the patch has a length of zero

pub fn overlaps(&self, other: &Self) -> bool

checks if two patches overlap each other

Example

use memoverlay::{SolidPatch, Patch};

let patch1 = Patch::new(10, &[0,1,2,3,4,5,6,7,8,9][..]).unwrap();
assert!(patch1.overlaps(&patch1));

let patch2 = Patch::new(12, &[1,2,3][..]).unwrap();
assert!(patch1.overlaps(&patch2));
assert!(patch2.overlaps(&patch1));

let patch3 = Patch::new(15, &[1,2,3,4,5][..]).unwrap();
assert!(patch1.overlaps(&patch3));
assert!(! patch2.overlaps(&patch3));

let patch4 = Patch::new(0, &[0,1,2,3,4,5,6,7,8,9][..]).unwrap();
assert!(! patch1.overlaps(&patch4));

pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<usize>

Trait Implementations

impl Contains for Patch

fn contains(&self, offset: u64) -> bool

impl Hash for Patch

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

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 Ord for Patch

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Patch> for Patch

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<Patch> for Patch

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl SolidPatch<&[u8]> for Patch

fn new(offset: u64, content: &[u8]) -> Result<Self, OverlayError>

impl SolidPatch<Vec<u8, Global>> for Patch

fn new(offset: u64, content: Vec<u8>) -> Result<Self, OverlayError>

impl Eq for Patch