Trait winsafe::prelude::kernel_Hheap

pub trait kernel_Hheap: Handle {
    // Provided methods
    fn GetProcessHeap() -> SysResult<HHEAP> { ... }
    fn GetProcessHeaps() -> SysResult<Vec<HHEAP>> { ... }
    fn HeapCreate(
        options: Option<HEAP_CREATE>,
        initial_size: usize,
        maximum_size: usize
    ) -> SysResult<HeapDestroyGuard> { ... }
    fn HeapAlloc(
        &self,
        flags: Option<HEAP_ALLOC>,
        num_bytes: usize
    ) -> SysResult<HeapFreeGuard<'_, Self>> { ... }
    fn HeapCompact(&self, flags: Option<HEAP_SIZE>) -> SysResult<usize> { ... }
    fn HeapLock(&self) -> SysResult<HeapUnlockGuard<'_, Self>> { ... }
    fn HeapReAlloc<'a>(
        &'a self,
        flags: Option<HEAP_REALLOC>,
        mem: &mut HeapFreeGuard<'a, Self>,
        num_bytes: usize
    ) -> SysResult<()> { ... }
    fn HeapSetInformation(
        &self,
        information_class: HEAP_INFORMATION,
        information: Option<&[u8]>
    ) -> SysResult<()> { ... }
    fn HeapSize(
        &self,
        flags: Option<HEAP_SIZE>,
        mem: &HeapFreeGuard<'_, Self>
    ) -> SysResult<usize> { ... }
    fn HeapValidate(
        &self,
        flags: Option<HEAP_SIZE>,
        mem: Option<&HeapFreeGuard<'_, Self>>
    ) -> bool { ... }
    fn HeapWalk(
        &self
    ) -> impl Iterator<Item = SysResult<&PROCESS_HEAP_ENTRY>> + '_ { ... }
}

Available on crate feature kernel only.

This trait is enabled with the kernel feature, and provides methods for HHEAP.

Prefer importing this trait through the prelude:

use winsafe::prelude::*;

Provided Methods

fn GetProcessHeap() -> SysResult<HHEAP>

GetProcessHeap function.

fn GetProcessHeaps() -> SysResult<Vec<HHEAP>>

GetProcessHeaps function.

fn HeapCreate( options: Option<HEAP_CREATE>, initial_size: usize, maximum_size: usize ) -> SysResult<HeapDestroyGuard>

HeapCreate function.

fn HeapAlloc( &self, flags: Option<HEAP_ALLOC>, num_bytes: usize ) -> SysResult<HeapFreeGuard<'_, Self>>

HeapAlloc function.

Examples

use winsafe::{self as w, prelude::*, co};

let heap = w::HHEAP::GetProcessHeap()?;

let mut block = heap.HeapAlloc(Some(co::HEAP_ALLOC::ZERO_MEMORY), 40)?;
block.as_mut_slice()[0] = 10;
block.as_mut_slice()[1] = 12;

for byte in block.as_slice().iter() {
    println!("{} ", byte);
}

// HeapFree() automatically called

fn HeapCompact(&self, flags: Option<HEAP_SIZE>) -> SysResult<usize>

HeapCompact function.

fn HeapLock(&self) -> SysResult<HeapUnlockGuard<'_, Self>>

HeapLock function.

You only need to call this method if the HHEAP was created with co::HEAP_CREATE::NO_SERIALIZE. Otherwise, the heap is already protected against concurrent thread access.

In the original C implementation, you must call HeapUnlock as a cleanup operation; here, the cleanup is performed automatically, because HeapLock returns a HeapUnlockGuard, which automatically calls HeapUnlock when the guard goes out of scope. You must, however, keep the guard alive, otherwise the cleanup will be performed right away.

Examples

use winsafe::{self as w, prelude::*, co};

let heap = w::HHEAP::HeapCreate(
    Some(co::HEAP_CREATE::NO_SERIALIZE), 0, 0)?;

let _lock = heap.HeapLock()?;

// heap operations...

// HeapUnlock() automatically called

// HeapDestroy() automatically called

fn HeapReAlloc<'a>( &'a self, flags: Option<HEAP_REALLOC>, mem: &mut HeapFreeGuard<'a, Self>, num_bytes: usize ) -> SysResult<()>

HeapReAlloc function.

Originally this method returns the handle to the reallocated memory object; here the original handle, present inside HeapFreeGuard, is automatically updated.

Examples

use winsafe::{self as w, prelude::*, co};

let heap = w::HHEAP::GetProcessHeap()?;
let mut array = heap.HeapAlloc(Some(co::HEAP_ALLOC::ZERO_MEMORY), 40)?;

heap.HeapReAlloc(Some(co::HEAP_REALLOC::ZERO_MEMORY), &mut array, 65)?;

// HeapFree() automatically called

fn HeapSetInformation( &self, information_class: HEAP_INFORMATION, information: Option<&[u8]> ) -> SysResult<()>

HeapSetInformation function.

fn HeapSize( &self, flags: Option<HEAP_SIZE>, mem: &HeapFreeGuard<'_, Self> ) -> SysResult<usize>

HeapSize function.

fn HeapValidate( &self, flags: Option<HEAP_SIZE>, mem: Option<&HeapFreeGuard<'_, Self>> ) -> bool

HeapValidate function.

Examples

use winsafe::{self as w, prelude::*, co};

let heap = w::HHEAP::GetProcessHeap()?;
let mut array = heap.HeapAlloc(Some(co::HEAP_ALLOC::ZERO_MEMORY), 40)?;

let is_ok = heap.HeapValidate(None, Some(&array));

// HeapFree() automatically called

fn HeapWalk(&self) -> impl Iterator<Item = SysResult<&PROCESS_HEAP_ENTRY>> + '_

HeapWalk function.

Returns an iterator over the heap memory blocks, exposing PROCESS_HEAP_ENTRY structs.

Examples

use winsafe::{self as w, prelude::*, co};

let heap = w::HHEAP::GetProcessHeap()?;

for block in heap.HeapWalk() {
    let block = block?;
    println!("Size: {}, overhead? {}",
        block.cbData, block.cbOverhead);
}

Object Safety

This trait is not object safe.

Implementors

impl kernel_Hheap for HHEAP